dom/indexedDB/IDBDatabase.cpp

   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 /* ***** BEGIN LICENSE BLOCK *****
   4  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version
   7  * 1.1 (the "License"); you may not use this file except in compliance with
   8  * the License. You may obtain a copy of the License at
   9  * http://www.mozilla.org/MPL/
  10  *
  11  * Software distributed under the License is distributed on an "AS IS" basis,
  12  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  13  * for the specific language governing rights and limitations under the
  14  * License.
  15  *
  16  * The Original Code is Indexed Database.
  17  *
  18  * The Initial Developer of the Original Code is
  19  * The Mozilla Foundation.
  20  * Portions created by the Initial Developer are Copyright (C) 2010
  21  * the Initial Developer. All Rights Reserved.
  22  *
  23  * Contributor(s):
  24  *   Ben Turner <bent.mozilla@gmail.com>
  25  *
  26  * Alternatively, the contents of this file may be used under the terms of
  27  * either the GNU General Public License Version 2 or later (the "GPL"), or
  28  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  29  * in which case the provisions of the GPL or the LGPL are applicable instead
  30  * of those above. If you wish to allow use of your version of this file only
  31  * under the terms of either the GPL or the LGPL, and not to allow others to
  32  * use your version of this file under the terms of the MPL, indicate your
  33  * decision by deleting the provisions above and replace them with the notice
  34  * and other provisions required by the GPL or the LGPL. If you do not delete
  35  * the provisions above, a recipient may use your version of this file under
  36  * the terms of any one of the MPL, the GPL or the LGPL.
  37  *
  38  * ***** END LICENSE BLOCK ***** */
  39
  40 #include "IDBDatabase.h"
  41
  42 #include "jscntxt.h"
  43 #include "mozilla/Mutex.h"
  44 #include "mozilla/storage.h"
  45 #include "nsDOMClassInfo.h"
  46 #include "nsEventDispatcher.h"
  47 #include "nsJSUtils.h"
  48 #include "nsProxyRelease.h"
  49 #include "nsThreadUtils.h"
  50
  51 #include "AsyncConnectionHelper.h"
  52 #include "CheckQuotaHelper.h"
  53 #include "DatabaseInfo.h"
  54 #include "IDBEvents.h"
  55 #include "IDBIndex.h"
  56 #include "IDBObjectStore.h"
  57 #include "IDBTransaction.h"
  58 #include "IDBFactory.h"
  59 #include "IndexedDatabaseManager.h"
  60 #include "LazyIdleThread.h"
  61 #include "TransactionThreadPool.h"
  62
  63 USING_INDEXEDDB_NAMESPACE
  64
  65 namespace {
  66
  67 const PRUint32 kDefaultDatabaseTimeoutSeconds = 30;
  68
  69 PRUint32 gDatabaseInstanceCount = 0;
  70 mozilla::Mutex* gPromptHelpersMutex = nsnull;
  71
  72 // Protected by gPromptHelpersMutex.
  73 nsTArray<nsRefPtr<CheckQuotaHelper> >* gPromptHelpers = nsnull;
  74
  75 class SetVersionHelper : public AsyncConnectionHelper
  76 {
  77 public:
  78   SetVersionHelper(IDBTransaction* aTransaction,
  79                    IDBRequest* aRequest,
  80                    const nsAString& aVersion)
  81   : AsyncConnectionHelper(aTransaction, aRequest), mVersion(aVersion)
  82   { }
  83
  84   nsresult DoDatabaseWork(mozIStorageConnection* aConnection);
  85   nsresult GetSuccessResult(nsIWritableVariant* aResult);
  86
  87 private:
  88   // In-params
  89   nsString mVersion;
  90 };
  91
  92 class CreateObjectStoreHelper : public AsyncConnectionHelper
  93 {
  94 public:
  95   CreateObjectStoreHelper(IDBTransaction* aTransaction,
  96                           IDBObjectStore* aObjectStore)
  97   : AsyncConnectionHelper(aTransaction, nsnull), mObjectStore(aObjectStore)
  98   { }
  99
 100   nsresult DoDatabaseWork(mozIStorageConnection* aConnection);
 101   nsresult OnSuccess(nsIDOMEventTarget* aTarget);
 102   void OnError(nsIDOMEventTarget* aTarget, nsresult aErrorCode);
 103
 104   void ReleaseMainThreadObjects()
 105   {
 106     mObjectStore = nsnull;
 107     AsyncConnectionHelper::ReleaseMainThreadObjects();
 108   }
 109
 110 private:
 111   nsRefPtr<IDBObjectStore> mObjectStore;
 112 };
 113
 114 class DeleteObjectStoreHelper : public AsyncConnectionHelper
 115 {
 116 public:
 117   DeleteObjectStoreHelper(IDBTransaction* aTransaction,
 118                           PRInt64 aObjectStoreId)
 119   : AsyncConnectionHelper(aTransaction, nsnull), mObjectStoreId(aObjectStoreId)
 120   { }
 121
 122   nsresult DoDatabaseWork(mozIStorageConnection* aConnection);
 123   nsresult OnSuccess(nsIDOMEventTarget* aTarget);
 124   void OnError(nsIDOMEventTarget* aTarget, nsresult aErrorCode);
 125
 126 private:
 127   // In-params.
 128   PRInt64 mObjectStoreId;
 129 };
 130
 131 NS_STACK_CLASS
 132 class AutoFree
 133 {
 134 public:
 135   AutoFree(void* aPtr) : mPtr(aPtr) { }
 136   ~AutoFree() { NS_Free(mPtr); }
 137 private:
 138   void* mPtr;
 139 };
 140
 141 NS_STACK_CLASS
 142 class AutoRemoveObjectStore
 143 {
 144 public:
 145   AutoRemoveObjectStore(PRUint32 aId, const nsAString& aName)
 146   : mId(aId), mName(aName)
 147   { }
 148
 149   ~AutoRemoveObjectStore()
 150   {
 151     if (mId) {
 152       ObjectStoreInfo::Remove(mId, mName);
 153     }
 154   }
 155
 156   void forget()
 157   {
 158     mId = 0;
 159   }
 160
 161 private:
 162   PRUint32 mId;
 163   nsString mName;
 164 };
 165
 166 inline
 167 nsresult
 168 ConvertVariantToStringArray(nsIVariant* aVariant,
 169                             nsTArray<nsString>& aStringArray)
 170 {
 171 #ifdef DEBUG
 172   PRUint16 type;
 173   NS_ASSERTION(NS_SUCCEEDED(aVariant->GetDataType(&type)) &&
 174                type == nsIDataType::VTYPE_ARRAY, "Bad arg!");
 175 #endif
 176
 177   PRUint16 valueType;
 178   nsIID iid;
 179   PRUint32 valueCount;
 180   void* rawArray;
 181
 182   nsresult rv = aVariant->GetAsArray(&valueType, &iid, &valueCount, &rawArray);
 183   NS_ENSURE_SUCCESS(rv, rv);
 184
 185   AutoFree af(rawArray);
 186
 187   // Just delete anything that we don't expect and return.
 188   if (valueType != nsIDataType::VTYPE_WCHAR_STR) {
 189     switch (valueType) {
 190       case nsIDataType::VTYPE_ID:
 191       case nsIDataType::VTYPE_CHAR_STR: {
 192         char** charArray = reinterpret_cast<char**>(rawArray);
 193         for (PRUint32 index = 0; index < valueCount; index++) {
 194           if (charArray[index]) {
 195             NS_Free(charArray[index]);
 196           }
 197         }
 198       } break;
 199
 200       case nsIDataType::VTYPE_INTERFACE:
 201       case nsIDataType::VTYPE_INTERFACE_IS: {
 202         nsISupports** supportsArray = reinterpret_cast<nsISupports**>(rawArray);
 203         for (PRUint32 index = 0; index < valueCount; index++) {
 204           NS_IF_RELEASE(supportsArray[index]);
 205         }
 206       } break;
 207
 208       default: {
 209         // The other types are primitives that do not need to be freed.
 210       }
 211     }
 212
 213     return NS_ERROR_ILLEGAL_VALUE;
 214   }
 215
 216   PRUnichar** strings = reinterpret_cast<PRUnichar**>(rawArray);
 217
 218   for (PRUint32 index = 0; index < valueCount; index++) {
 219     nsString* newString = aStringArray.AppendElement();
 220
 221     if (!newString) {
 222       NS_ERROR("Out of memory?");
 223       for (; index < valueCount; index++) {
 224         NS_Free(strings[index]);
 225       }
 226       return NS_ERROR_OUT_OF_MEMORY;
 227     }
 228
 229     newString->Adopt(strings[index], -1);
 230   }
 231
 232   return NS_OK;
 233 }
 234
 235 } // anonymous namespace
 236
 237 // static
 238 already_AddRefed<IDBDatabase>
 239 IDBDatabase::Create(nsIScriptContext* aScriptContext,
 240                     nsPIDOMWindow* aOwner,
 241                     DatabaseInfo* aDatabaseInfo,
 242                     const nsACString& aASCIIOrigin)
 243 {
 244   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 245   NS_ASSERTION(aDatabaseInfo, "Null pointer!");
 246   NS_ASSERTION(!aASCIIOrigin.IsEmpty(), "Empty origin!");
 247
 248   nsRefPtr<IDBDatabase> db(new IDBDatabase());
 249
 250   db->mScriptContext = aScriptContext;
 251   db->mOwner = aOwner;
 252
 253   db->mDatabaseId = aDatabaseInfo->id;
 254   db->mName = aDatabaseInfo->name;
 255   db->mFilePath = aDatabaseInfo->filePath;
 256   db->mASCIIOrigin = aASCIIOrigin;
 257
 258   IndexedDatabaseManager* mgr = IndexedDatabaseManager::Get();
 259   NS_ASSERTION(mgr, "This should never be null!");
 260
 261   if (!mgr->RegisterDatabase(db)) {
 262     // Either out of memory or shutting down.
 263     return nsnull;
 264   }
 265
 266   return db.forget();
 267 }
 268
 269 IDBDatabase::IDBDatabase()
 270 : mDatabaseId(0),
 271   mInvalidated(0),
 272   mRegistered(false),
 273   mClosed(false)
 274 {
 275   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 276
 277   if (!gDatabaseInstanceCount++) {
 278     NS_ASSERTION(!gPromptHelpersMutex, "Should be null!");
 279     gPromptHelpersMutex = new mozilla::Mutex("IDBDatabase gPromptHelpersMutex");
 280   }
 281 }
 282
 283 IDBDatabase::~IDBDatabase()
 284 {
 285   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 286
 287   if (mRegistered) {
 288     CloseInternal();
 289
 290     IndexedDatabaseManager* mgr = IndexedDatabaseManager::Get();
 291     if (mgr) {
 292       mgr->UnregisterDatabase(this);
 293     }
 294   }
 295
 296   if (mDatabaseId && !mInvalidated) {
 297     DatabaseInfo* info;
 298     if (!DatabaseInfo::Get(mDatabaseId, &info)) {
 299       NS_ERROR("This should never fail!");
 300     }
 301
 302     NS_ASSERTION(info->referenceCount, "Bad reference count!");
 303     if (--info->referenceCount == 0) {
 304       DatabaseInfo::Remove(mDatabaseId);
 305     }
 306   }
 307
 308   if (mListenerManager) {
 309     mListenerManager->Disconnect();
 310   }
 311
 312   if (!--gDatabaseInstanceCount) {
 313     NS_ASSERTION(gPromptHelpersMutex, "Should not be null!");
 314
 315     delete gPromptHelpers;
 316     gPromptHelpers = nsnull;
 317
 318     delete gPromptHelpersMutex;
 319     gPromptHelpersMutex = nsnull;
 320   }
 321 }
 322
 323 bool
 324 IDBDatabase::IsQuotaDisabled()
 325 {
 326   NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
 327   NS_ASSERTION(gPromptHelpersMutex, "This should never be null!");
 328
 329   MutexAutoLock lock(*gPromptHelpersMutex);
 330
 331   if (!gPromptHelpers) {
 332     gPromptHelpers = new nsAutoTArray<nsRefPtr<CheckQuotaHelper>, 10>();
 333   }
 334
 335   CheckQuotaHelper* foundHelper = nsnull;
 336
 337   PRUint32 count = gPromptHelpers->Length();
 338   for (PRUint32 index = 0; index < count; index++) {
 339     nsRefPtr<CheckQuotaHelper>& helper = gPromptHelpers->ElementAt(index);
 340     if (helper->WindowSerial() == Owner()->GetSerial()) {
 341       foundHelper = helper;
 342       break;
 343     }
 344   }
 345
 346   if (!foundHelper) {
 347     nsRefPtr<CheckQuotaHelper>* newHelper = gPromptHelpers->AppendElement();
 348     if (!newHelper) {
 349       NS_WARNING("Out of memory!");
 350       return false;
 351     }
 352     *newHelper = new CheckQuotaHelper(this, *gPromptHelpersMutex);
 353     foundHelper = *newHelper;
 354
 355     {
 356       // Unlock before calling out to XPCOM.
 357       MutexAutoUnlock unlock(*gPromptHelpersMutex);
 358
 359       nsresult rv = NS_DispatchToMainThread(foundHelper, NS_DISPATCH_NORMAL);
 360       NS_ENSURE_SUCCESS(rv, false);
 361     }
 362   }
 363
 364   return foundHelper->PromptAndReturnQuotaIsDisabled();
 365 }
 366
 367 void
 368 IDBDatabase::Invalidate()
 369 {
 370   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 371   NS_ASSERTION(gPromptHelpersMutex, "This should never be null!");
 372
 373   // Make sure we're closed too.
 374   Close();
 375
 376   // Cancel any quota prompts that are currently being displayed.
 377   {
 378     MutexAutoLock lock(*gPromptHelpersMutex);
 379
 380     if (gPromptHelpers) {
 381       PRUint32 count = gPromptHelpers->Length();
 382       for (PRUint32 index = 0; index < count; index++) {
 383         nsRefPtr<CheckQuotaHelper>& helper = gPromptHelpers->ElementAt(index);
 384         if (helper->WindowSerial() == Owner()->GetSerial()) {
 385           helper->Cancel();
 386           break;
 387         }
 388       }
 389     }
 390   }
 391
 392   if (!PR_AtomicSet(&mInvalidated, 1)) {
 393     DatabaseInfo* info;
 394     if (!DatabaseInfo::Get(mDatabaseId, &info)) {
 395       NS_ERROR("This should never fail!");
 396     }
 397
 398     NS_ASSERTION(info->referenceCount, "Bad reference count!");
 399     if (--info->referenceCount == 0) {
 400       DatabaseInfo::Remove(mDatabaseId);
 401     }
 402   }
 403 }
 404
 405 bool
 406 IDBDatabase::IsInvalidated()
 407 {
 408   return !!mInvalidated;
 409 }
 410
 411 void
 412 IDBDatabase::CloseInternal()
 413 {
 414   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 415
 416   if (!mClosed) {
 417     IndexedDatabaseManager* mgr = IndexedDatabaseManager::Get();
 418     if (mgr) {
 419       mgr->OnDatabaseClosed(this);
 420     }
 421     mClosed = true;
 422   }
 423 }
 424
 425 bool
 426 IDBDatabase::IsClosed()
 427 {
 428   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 429   return mClosed;
 430 }
 431
 432 void
 433 IDBDatabase::OnUnlink()
 434 {
 435   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 436   NS_ASSERTION(!mOwner, "Should have been cleared already!");
 437
 438   // We've been unlinked, at the very least we should be able to prevent further
 439   // transactions from starting and unblock any other SetVersion callers.
 440   Close();
 441
 442   // No reason for the IndexedDatabaseManager to track us any longer.
 443   IndexedDatabaseManager* mgr = IndexedDatabaseManager::Get();
 444   if (mgr) {
 445     mgr->UnregisterDatabase(this);
 446
 447     // Don't try to unregister again in the destructor.
 448     mRegistered = false;
 449   }
 450 }
 451
 452 NS_IMPL_CYCLE_COLLECTION_CLASS(IDBDatabase)
 453
 454 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(IDBDatabase,
 455                                                   nsDOMEventTargetHelper)
 456   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOnErrorListener)
 457   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_NSCOMPTR(mOnVersionChangeListener)
 458 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 459
 460 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(IDBDatabase,
 461                                                 nsDOMEventTargetHelper)
 462   NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOnErrorListener)
 463   NS_IMPL_CYCLE_COLLECTION_UNLINK_NSCOMPTR(mOnVersionChangeListener)
 464
 465   // Do some cleanup.
 466   tmp->OnUnlink();
 467 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 468
 469 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION_INHERITED(IDBDatabase)
 470   NS_INTERFACE_MAP_ENTRY(nsIIDBDatabase)
 471   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(IDBDatabase)
 472 NS_INTERFACE_MAP_END_INHERITING(nsDOMEventTargetHelper)
 473
 474 NS_IMPL_ADDREF_INHERITED(IDBDatabase, nsDOMEventTargetHelper)
 475 NS_IMPL_RELEASE_INHERITED(IDBDatabase, nsDOMEventTargetHelper)
 476
 477 DOMCI_DATA(IDBDatabase, IDBDatabase)
 478
 479 NS_IMETHODIMP
 480 IDBDatabase::GetName(nsAString& aName)
 481 {
 482   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 483   aName.Assign(mName);
 484   return NS_OK;
 485 }
 486
 487 NS_IMETHODIMP
 488 IDBDatabase::GetVersion(nsAString& aVersion)
 489 {
 490   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 491   DatabaseInfo* info;
 492   if (!DatabaseInfo::Get(mDatabaseId, &info)) {
 493     NS_ERROR("This should never fail!");
 494   }
 495   aVersion.Assign(info->version);
 496   return NS_OK;
 497 }
 498
 499 NS_IMETHODIMP
 500 IDBDatabase::GetObjectStoreNames(nsIDOMDOMStringList** aObjectStores)
 501 {
 502   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 503
 504   DatabaseInfo* info;
 505   if (!DatabaseInfo::Get(mDatabaseId, &info)) {
 506     NS_ERROR("This should never fail!");
 507   }
 508
 509   nsAutoTArray<nsString, 10> objectStoreNames;
 510   if (!info->GetObjectStoreNames(objectStoreNames)) {
 511     NS_WARNING("Couldn't get names!");
 512     return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 513   }
 514
 515   nsRefPtr<nsDOMStringList> list(new nsDOMStringList());
 516   PRUint32 count = objectStoreNames.Length();
 517   for (PRUint32 index = 0; index < count; index++) {
 518     NS_ENSURE_TRUE(list->Add(objectStoreNames[index]),
 519                    NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 520   }
 521
 522   list.forget(aObjectStores);
 523   return NS_OK;
 524 }
 525
 526 NS_IMETHODIMP
 527 IDBDatabase::CreateObjectStore(const nsAString& aName,
 528                                const jsval& aOptions,
 529                                JSContext* aCx,
 530                                nsIIDBObjectStore** _retval)
 531 {
 532   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 533
 534   if (aName.IsEmpty()) {
 535     // XXX Update spec for a real error code here.
 536     return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR;
 537   }
 538
 539   IDBTransaction* transaction = AsyncConnectionHelper::GetCurrentTransaction();
 540
 541   if (!transaction ||
 542       transaction->Mode() != nsIIDBTransaction::VERSION_CHANGE) {
 543     return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
 544   }
 545
 546   DatabaseInfo* databaseInfo;
 547   if (!DatabaseInfo::Get(mDatabaseId, &databaseInfo)) {
 548     NS_ERROR("This should never fail!");
 549   }
 550
 551   if (databaseInfo->ContainsStoreName(aName)) {
 552     return NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR;
 553   }
 554
 555   nsString keyPath;
 556   bool autoIncrement = false;
 557
 558   if (!JSVAL_IS_VOID(aOptions) && !JSVAL_IS_NULL(aOptions)) {
 559     if (JSVAL_IS_PRIMITIVE(aOptions)) {
 560       // XXX Update spec for a real code here
 561       return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR;
 562     }
 563
 564     NS_ASSERTION(JSVAL_IS_OBJECT(aOptions), "Huh?!");
 565     JSObject* options = JSVAL_TO_OBJECT(aOptions);
 566
 567     js::AutoIdArray ids(aCx, JS_Enumerate(aCx, options));
 568     if (!ids) {
 569       return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 570     }
 571
 572     for (size_t index = 0; index < ids.length(); index++) {
 573       jsid id = ids[index];
 574
 575       if (id != nsDOMClassInfo::sKeyPath_id &&
 576           id != nsDOMClassInfo::sAutoIncrement_id) {
 577         // XXX Update spec for a real code here
 578         return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR;
 579       }
 580
 581       jsval val;
 582       if (!JS_GetPropertyById(aCx, options, id, &val)) {
 583         NS_WARNING("JS_GetPropertyById failed!");
 584         return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 585       }
 586
 587       if (id == nsDOMClassInfo::sKeyPath_id) {
 588         JSString* str = JS_ValueToString(aCx, val);
 589         if (!str) {
 590           NS_WARNING("JS_ValueToString failed!");
 591           return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 592         }
 593         nsDependentJSString dependentKeyPath;
 594         if (!dependentKeyPath.init(aCx, str)) {
 595           NS_WARNING("Initializing keyPath failed!");
 596           return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 597         }
 598         keyPath = dependentKeyPath;
 599       }
 600       else if (id == nsDOMClassInfo::sAutoIncrement_id) {
 601         JSBool boolVal;
 602         if (!JS_ValueToBoolean(aCx, val, &boolVal)) {
 603           NS_WARNING("JS_ValueToBoolean failed!");
 604           return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 605         }
 606         autoIncrement = !!boolVal;
 607       }
 608       else {
 609         NS_NOTREACHED("Shouldn't be able to get here!");
 610       }
 611     }
 612   }
 613
 614   nsAutoPtr<ObjectStoreInfo> newInfo(new ObjectStoreInfo());
 615
 616   newInfo->name = aName;
 617   newInfo->id = databaseInfo->nextObjectStoreId++;
 618   newInfo->keyPath = keyPath;
 619   newInfo->autoIncrement = autoIncrement;
 620   newInfo->databaseId = mDatabaseId;
 621
 622   if (!ObjectStoreInfo::Put(newInfo)) {
 623     NS_WARNING("Put failed!");
 624     return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 625   }
 626   ObjectStoreInfo* objectStoreInfo = newInfo.forget();
 627
 628   // Don't leave this in the hash if we fail below!
 629   AutoRemoveObjectStore autoRemove(mDatabaseId, aName);
 630
 631   nsRefPtr<IDBObjectStore> objectStore =
 632     transaction->GetOrCreateObjectStore(aName, objectStoreInfo);
 633   NS_ENSURE_TRUE(objectStore, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 634
 635   nsRefPtr<CreateObjectStoreHelper> helper =
 636     new CreateObjectStoreHelper(transaction, objectStore);
 637
 638   nsresult rv = helper->DispatchToTransactionPool();
 639   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 640
 641   autoRemove.forget();
 642
 643   objectStore.forget(_retval);
 644   return NS_OK;
 645 }
 646
 647 NS_IMETHODIMP
 648 IDBDatabase::DeleteObjectStore(const nsAString& aName)
 649 {
 650   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 651
 652   IDBTransaction* transaction = AsyncConnectionHelper::GetCurrentTransaction();
 653
 654   if (!transaction ||
 655       transaction->Mode() != nsIIDBTransaction::VERSION_CHANGE) {
 656     return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
 657   }
 658
 659   ObjectStoreInfo* objectStoreInfo;
 660   if (!ObjectStoreInfo::Get(mDatabaseId, aName, &objectStoreInfo)) {
 661     return NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR;
 662   }
 663
 664   nsRefPtr<DeleteObjectStoreHelper> helper =
 665     new DeleteObjectStoreHelper(transaction, objectStoreInfo->id);
 666   nsresult rv = helper->DispatchToTransactionPool();
 667   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 668
 669   ObjectStoreInfo::Remove(mDatabaseId, aName);
 670   return NS_OK;
 671 }
 672
 673 NS_IMETHODIMP
 674 IDBDatabase::SetVersion(const nsAString& aVersion,
 675                         JSContext* aCx,
 676                         nsIIDBRequest** _retval)
 677 {
 678   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 679
 680   if (mClosed) {
 681     // XXX Update spec for a real error code here.
 682     return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
 683   }
 684
 685   DatabaseInfo* info;
 686   if (!DatabaseInfo::Get(mDatabaseId, &info)) {
 687     NS_ERROR("This should never fail!");
 688   }
 689
 690   // Lock the whole database.
 691   nsTArray<nsString> storesToOpen;
 692   nsRefPtr<IDBTransaction> transaction =
 693     IDBTransaction::Create(this, storesToOpen, IDBTransaction::VERSION_CHANGE,
 694                            kDefaultDatabaseTimeoutSeconds, true);
 695   NS_ENSURE_TRUE(transaction, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 696
 697   nsRefPtr<IDBVersionChangeRequest> request =
 698     IDBVersionChangeRequest::Create(static_cast<nsPIDOMEventTarget*>(this),
 699                                     ScriptContext(), Owner(), transaction);
 700   NS_ENSURE_TRUE(request, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 701
 702   nsRefPtr<SetVersionHelper> helper =
 703     new SetVersionHelper(transaction, request, aVersion);
 704
 705   IndexedDatabaseManager* mgr = IndexedDatabaseManager::Get();
 706   NS_ASSERTION(mgr, "This should never be null!");
 707
 708   nsresult rv = mgr->SetDatabaseVersion(this, request, aVersion, helper);
 709   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 710
 711   request.forget(_retval);
 712   return NS_OK;
 713 }
 714
 715 NS_IMETHODIMP
 716 IDBDatabase::Transaction(nsIVariant* aStoreNames,
 717                          PRUint16 aMode,
 718                          PRUint32 aTimeout,
 719                          JSContext* aCx,
 720                          PRUint8 aOptionalArgCount,
 721                          nsIIDBTransaction** _retval)
 722 {
 723   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 724
 725   if (IndexedDatabaseManager::IsShuttingDown()) {
 726     return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 727   }
 728
 729   if (mClosed) {
 730     return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
 731   }
 732
 733   if (aOptionalArgCount) {
 734     if (aMode != nsIIDBTransaction::READ_WRITE &&
 735         aMode != nsIIDBTransaction::READ_ONLY &&
 736         aMode != nsIIDBTransaction::SNAPSHOT_READ) {
 737       return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR;
 738     }
 739     if (aMode == nsIIDBTransaction::SNAPSHOT_READ) {
 740       NS_NOTYETIMPLEMENTED("Implement me!");
 741       return NS_ERROR_NOT_IMPLEMENTED;
 742     }
 743   }
 744   else {
 745     aMode = nsIIDBTransaction::READ_ONLY;
 746   }
 747
 748   if (aOptionalArgCount <= 1) {
 749     aTimeout = kDefaultDatabaseTimeoutSeconds;
 750   }
 751
 752   PRUint16 type;
 753   nsresult rv = aStoreNames->GetDataType(&type);
 754   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 755
 756   DatabaseInfo* info;
 757   if (!DatabaseInfo::Get(mDatabaseId, &info)) {
 758     NS_ERROR("This should never fail!");
 759   }
 760
 761   nsTArray<nsString> storesToOpen;
 762
 763   switch (type) {
 764     case nsIDataType::VTYPE_VOID:
 765     case nsIDataType::VTYPE_EMPTY:
 766     case nsIDataType::VTYPE_EMPTY_ARRAY: {
 767       // Empty, request all object stores
 768       if (!info->GetObjectStoreNames(storesToOpen)) {
 769         NS_WARNING("Out of memory?");
 770         return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 771       }
 772     } break;
 773
 774     case nsIDataType::VTYPE_WSTRING_SIZE_IS: {
 775       // Single name
 776       nsString name;
 777       rv = aStoreNames->GetAsAString(name);
 778       NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 779
 780       if (!info->ContainsStoreName(name)) {
 781         return NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR;
 782       }
 783
 784       if (!storesToOpen.AppendElement(name)) {
 785         NS_WARNING("Out of memory?");
 786         return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 787       }
 788     } break;
 789
 790     case nsIDataType::VTYPE_ARRAY: {
 791       nsTArray<nsString> names;
 792       rv = ConvertVariantToStringArray(aStoreNames, names);
 793       NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 794
 795       PRUint32 nameCount = names.Length();
 796       for (PRUint32 nameIndex = 0; nameIndex < nameCount; nameIndex++) {
 797         nsString& name = names[nameIndex];
 798
 799         if (!info->ContainsStoreName(name)) {
 800           return NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR;
 801         }
 802
 803         if (!storesToOpen.AppendElement(name)) {
 804           NS_WARNING("Out of memory?");
 805           return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 806         }
 807       }
 808       NS_ASSERTION(nameCount == storesToOpen.Length(), "Should have bailed!");
 809     } break;
 810
 811     case nsIDataType::VTYPE_INTERFACE:
 812     case nsIDataType::VTYPE_INTERFACE_IS: {
 813       nsCOMPtr<nsISupports> supports;
 814       nsID *iid;
 815       rv = aStoreNames->GetAsInterface(&iid, getter_AddRefs(supports));
 816       NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 817
 818       NS_Free(iid);
 819
 820       nsCOMPtr<nsIDOMDOMStringList> stringList(do_QueryInterface(supports));
 821       if (!stringList) {
 822         // We don't support anything other than nsIDOMDOMStringList.
 823         return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR;
 824       }
 825
 826       PRUint32 stringCount;
 827       rv = stringList->GetLength(&stringCount);
 828       NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 829
 830       for (PRUint32 stringIndex = 0; stringIndex < stringCount; stringIndex++) {
 831         nsString name;
 832         rv = stringList->Item(stringIndex, name);
 833         NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 834
 835         if (!info->ContainsStoreName(name)) {
 836           return NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR;
 837         }
 838
 839         if (!storesToOpen.AppendElement(name)) {
 840           NS_WARNING("Out of memory?");
 841           return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 842         }
 843       }
 844     } break;
 845
 846     default:
 847       return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR;
 848   }
 849
 850   nsRefPtr<IDBTransaction> transaction =
 851     IDBTransaction::Create(this, storesToOpen, aMode,
 852                            kDefaultDatabaseTimeoutSeconds);
 853   NS_ENSURE_TRUE(transaction, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 854
 855   transaction.forget(_retval);
 856   return NS_OK;
 857 }
 858
 859 NS_IMETHODIMP
 860 IDBDatabase::Close()
 861 {
 862   NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
 863
 864   CloseInternal();
 865
 866   NS_ASSERTION(mClosed, "Should have set the closed flag!");
 867   return NS_OK;
 868 }
 869
 870 NS_IMETHODIMP
 871 IDBDatabase::SetOnerror(nsIDOMEventListener* aErrorListener)
 872 {
 873   return RemoveAddEventListener(NS_LITERAL_STRING(ERROR_EVT_STR),
 874                                 mOnErrorListener, aErrorListener);
 875 }
 876
 877 NS_IMETHODIMP
 878 IDBDatabase::GetOnerror(nsIDOMEventListener** aErrorListener)
 879 {
 880   return GetInnerEventListener(mOnErrorListener, aErrorListener);
 881 }
 882
 883 NS_IMETHODIMP
 884 IDBDatabase::SetOnversionchange(nsIDOMEventListener* aVersionChangeListener)
 885 {
 886   return RemoveAddEventListener(NS_LITERAL_STRING(VERSIONCHANGE_EVT_STR),
 887                                 mOnVersionChangeListener,
 888                                 aVersionChangeListener);
 889 }
 890
 891 NS_IMETHODIMP
 892 IDBDatabase::GetOnversionchange(nsIDOMEventListener** aVersionChangeListener)
 893 {
 894   return GetInnerEventListener(mOnVersionChangeListener,
 895                                aVersionChangeListener);
 896 }
 897
 898 nsresult
 899 IDBDatabase::PostHandleEvent(nsEventChainPostVisitor& aVisitor)
 900 {
 901   NS_ENSURE_TRUE(aVisitor.mDOMEvent, NS_ERROR_UNEXPECTED);
 902
 903   if (aVisitor.mEventStatus != nsEventStatus_eConsumeNoDefault) {
 904     nsCOMPtr<nsIDOMEvent> duplicateEvent =
 905       IDBErrorEvent::MaybeDuplicate(aVisitor.mDOMEvent);
 906
 907     if (duplicateEvent) {
 908       nsCOMPtr<nsIDOMEventTarget> target(do_QueryInterface(mOwner));
 909       NS_ASSERTION(target, "How can this happen?!");
 910
 911       PRBool dummy;
 912       target->DispatchEvent(duplicateEvent, &dummy);
 913     }
 914   }
 915
 916   return NS_OK;
 917 }
 918
 919 nsresult
 920 SetVersionHelper::DoDatabaseWork(mozIStorageConnection* aConnection)
 921 {
 922   NS_PRECONDITION(aConnection, "Passing a null connection!");
 923
 924   nsCOMPtr<mozIStorageStatement> stmt;
 925   nsresult rv = aConnection->CreateStatement(NS_LITERAL_CSTRING(
 926     "UPDATE database "
 927     "SET version = :version"
 928   ), getter_AddRefs(stmt));
 929   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 930
 931   rv = stmt->BindStringByName(NS_LITERAL_CSTRING("version"), mVersion);
 932   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 933
 934   if (NS_FAILED(stmt->Execute())) {
 935     return NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR;
 936   }
 937
 938   return NS_OK;
 939 }
 940
 941 nsresult
 942 SetVersionHelper::GetSuccessResult(nsIWritableVariant* aResult)
 943 {
 944   DatabaseInfo* info;
 945   if (!DatabaseInfo::Get(mDatabase->Id(), &info)) {
 946     NS_ERROR("This should never fail!");
 947     return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
 948   }
 949   info->version = mVersion;
 950
 951   aResult->SetAsISupports(static_cast<nsPIDOMEventTarget*>(mTransaction));
 952   return NS_OK;
 953 }
 954
 955 nsresult
 956 CreateObjectStoreHelper::DoDatabaseWork(mozIStorageConnection* aConnection)
 957 {
 958   nsCOMPtr<mozIStorageStatement> stmt =
 959     mTransaction->GetCachedStatement(NS_LITERAL_CSTRING(
 960     "INSERT INTO object_store (id, name, key_path, auto_increment) "
 961     "VALUES (:id, :name, :key_path, :auto_increment)"
 962   ));
 963   NS_ENSURE_TRUE(stmt, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 964
 965   mozStorageStatementScoper scoper(stmt);
 966
 967   nsresult rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"),
 968                                        mObjectStore->Id());
 969   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 970
 971   rv = stmt->BindStringByName(NS_LITERAL_CSTRING("name"), mObjectStore->Name());
 972   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 973
 974   rv = stmt->BindStringByName(NS_LITERAL_CSTRING("key_path"),
 975                               mObjectStore->KeyPath());
 976   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 977
 978   rv = stmt->BindInt32ByName(NS_LITERAL_CSTRING("auto_increment"),
 979                              mObjectStore->IsAutoIncrement() ? 1 : 0);
 980   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 981
 982   rv = stmt->Execute();
 983   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
 984
 985   return NS_OK;
 986 }
 987
 988 nsresult
 989 CreateObjectStoreHelper::OnSuccess(nsIDOMEventTarget* aTarget)
 990 {
 991   NS_ASSERTION(!aTarget, "Huh?!");
 992   return NS_OK;
 993 }
 994
 995 void
 996 CreateObjectStoreHelper::OnError(nsIDOMEventTarget* aTarget,
 997                                  nsresult aErrorCode)
 998 {
 999   NS_ASSERTION(!aTarget, "Huh?!");
1000 }
1001
1002 nsresult
1003 DeleteObjectStoreHelper::DoDatabaseWork(mozIStorageConnection* aConnection)
1004 {
1005   nsCOMPtr<mozIStorageStatement> stmt =
1006     mTransaction->GetCachedStatement(NS_LITERAL_CSTRING(
1007     "DELETE FROM object_store "
1008     "WHERE id = :id "
1009   ));
1010   NS_ENSURE_TRUE(stmt, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
1011
1012   mozStorageStatementScoper scoper(stmt);
1013
1014   nsresult rv = stmt->BindInt64ByName(NS_LITERAL_CSTRING("id"), mObjectStoreId);
1015   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
1016
1017   rv = stmt->Execute();
1018   NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
1019
1020   return NS_OK;
1021 }
1022
1023 nsresult
1024 DeleteObjectStoreHelper::OnSuccess(nsIDOMEventTarget* aTarget)
1025 {
1026   NS_ASSERTION(!aTarget, "Huh?!");
1027
1028   return NS_OK;
1029 }
1030
1031 void
1032 DeleteObjectStoreHelper::OnError(nsIDOMEventTarget* aTarget,
1033                                  nsresult aErrorCode)
1034 {
1035   NS_NOTREACHED("Removing an object store should never fail here!");
1036 }