Drop IDBDatabaseException class
authorcdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 22 Jul 2017 04:43:37 +0000 (04:43 +0000)
committercdumez@apple.com <cdumez@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sat, 22 Jul 2017 04:43:37 +0000 (04:43 +0000)
https://bugs.webkit.org/show_bug.cgi?id=174743

Reviewed by Darin Adler.

LayoutTests/imported/w3c:

Rebaseline test as the exception message is slightly different.

* web-platform-tests/IndexedDB/keypath-special-identifiers-expected.txt:

Source/WebCore:

Drop IDBDatabaseException class and use DOMException directly. IDBDatabaseException was
only an internal concept and was already exposed to the Web as a DOMException. This
simplifies the code a bit and will allow for further simplification in a follow-up patch.

No new tests, no Web-facing behavior change, except for some exception messages
being slightly different.

* CMakeLists.txt:
* Modules/indexeddb/IDBCursor.cpp:
(WebCore::IDBCursor::update):
(WebCore::IDBCursor::advance):
(WebCore::IDBCursor::continuePrimaryKey):
(WebCore::IDBCursor::continueFunction):
(WebCore::IDBCursor::deleteFunction):
* Modules/indexeddb/IDBDatabase.cpp:
(WebCore::IDBDatabase::createObjectStore):
(WebCore::IDBDatabase::transaction):
(WebCore::IDBDatabase::deleteObjectStore):
* Modules/indexeddb/IDBDatabaseError.h: Removed.
* Modules/indexeddb/IDBDatabaseException.cpp: Removed.
* Modules/indexeddb/IDBDatabaseException.h: Removed.
* Modules/indexeddb/IDBFactory.cpp:
(WebCore::IDBFactory::cmp):
* Modules/indexeddb/IDBIndex.cpp:
(WebCore::IDBIndex::setName):
(WebCore::IDBIndex::openCursor):
(WebCore::IDBIndex::openKeyCursor):
(WebCore::IDBIndex::count):
(WebCore::IDBIndex::doCount):
(WebCore::IDBIndex::get):
(WebCore::IDBIndex::doGet):
(WebCore::IDBIndex::getKey):
(WebCore::IDBIndex::doGetKey):
(WebCore::IDBIndex::getAll):
(WebCore::IDBIndex::getAllKeys):
* Modules/indexeddb/IDBKeyRange.cpp:
(WebCore::IDBKeyRange::only):
(WebCore::IDBKeyRange::lowerBound):
(WebCore::IDBKeyRange::upperBound):
(WebCore::IDBKeyRange::bound):
(WebCore::IDBKeyRange::includes):
* Modules/indexeddb/IDBObjectStore.cpp:
(WebCore::IDBObjectStore::setName):
(WebCore::IDBObjectStore::openCursor):
(WebCore::IDBObjectStore::openKeyCursor):
(WebCore::IDBObjectStore::get):
(WebCore::IDBObjectStore::getKey):
(WebCore::IDBObjectStore::putOrAdd):
(WebCore::IDBObjectStore::doDelete):
(WebCore::IDBObjectStore::deleteFunction):
(WebCore::IDBObjectStore::clear):
(WebCore::IDBObjectStore::createIndex):
(WebCore::IDBObjectStore::index):
(WebCore::IDBObjectStore::deleteIndex):
(WebCore::IDBObjectStore::count):
(WebCore::IDBObjectStore::doCount):
(WebCore::IDBObjectStore::getAll):
(WebCore::IDBObjectStore::getAllKeys):
* Modules/indexeddb/IDBOpenDBRequest.cpp:
(WebCore::IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion):
* Modules/indexeddb/IDBRequest.cpp:
(WebCore::IDBRequest::result):
(WebCore::IDBRequest::error):
(WebCore::IDBRequest::uncaughtExceptionInEventHandler):
* Modules/indexeddb/IDBTransaction.cpp:
(WebCore::IDBTransaction::objectStore):
(WebCore::IDBTransaction::abort):
(WebCore::IDBTransaction::abortOnServerAndCancelRequests):
(WebCore::IDBTransaction::didCreateIndexOnServer):
(WebCore::IDBTransaction::putOrAddOnServer):
* Modules/indexeddb/server/IndexValueStore.cpp:
(WebCore::IDBServer::IndexValueStore::addRecord):
* Modules/indexeddb/server/MemoryIDBBackingStore.cpp:
(WebCore::IDBServer::MemoryIDBBackingStore::beginTransaction):
(WebCore::IDBServer::MemoryIDBBackingStore::abortTransaction):
(WebCore::IDBServer::MemoryIDBBackingStore::commitTransaction):
(WebCore::IDBServer::MemoryIDBBackingStore::createObjectStore):
(WebCore::IDBServer::MemoryIDBBackingStore::deleteObjectStore):
(WebCore::IDBServer::MemoryIDBBackingStore::renameObjectStore):
(WebCore::IDBServer::MemoryIDBBackingStore::clearObjectStore):
(WebCore::IDBServer::MemoryIDBBackingStore::createIndex):
(WebCore::IDBServer::MemoryIDBBackingStore::deleteIndex):
(WebCore::IDBServer::MemoryIDBBackingStore::renameIndex):
(WebCore::IDBServer::MemoryIDBBackingStore::deleteRange):
(WebCore::IDBServer::MemoryIDBBackingStore::addRecord):
(WebCore::IDBServer::MemoryIDBBackingStore::getRecord):
(WebCore::IDBServer::MemoryIDBBackingStore::getAllRecords):
(WebCore::IDBServer::MemoryIDBBackingStore::getIndexRecord):
(WebCore::IDBServer::MemoryIDBBackingStore::getCount):
(WebCore::IDBServer::MemoryIDBBackingStore::generateKeyNumber):
(WebCore::IDBServer::MemoryIDBBackingStore::openCursor):
(WebCore::IDBServer::MemoryIDBBackingStore::iterateCursor):
* Modules/indexeddb/server/MemoryIndex.cpp:
(WebCore::IDBServer::MemoryIndex::putIndexKey):
* Modules/indexeddb/server/MemoryObjectStore.cpp:
(WebCore::IDBServer::MemoryObjectStore::createIndex):
(WebCore::IDBServer::MemoryObjectStore::deleteIndex):
* Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:
(WebCore::IDBServer::SQLiteIDBBackingStore::getOrEstablishDatabaseInfo):
(WebCore::IDBServer::SQLiteIDBBackingStore::beginTransaction):
(WebCore::IDBServer::SQLiteIDBBackingStore::abortTransaction):
(WebCore::IDBServer::SQLiteIDBBackingStore::commitTransaction):
(WebCore::IDBServer::SQLiteIDBBackingStore::createObjectStore):
(WebCore::IDBServer::SQLiteIDBBackingStore::deleteObjectStore):
(WebCore::IDBServer::SQLiteIDBBackingStore::renameObjectStore):
(WebCore::IDBServer::SQLiteIDBBackingStore::clearObjectStore):
(WebCore::IDBServer::SQLiteIDBBackingStore::createIndex):
(WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedHasIndexRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedPutIndexKey):
(WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedPutIndexRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::deleteIndex):
(WebCore::IDBServer::SQLiteIDBBackingStore::renameIndex):
(WebCore::IDBServer::SQLiteIDBBackingStore::keyExistsInObjectStore):
(WebCore::IDBServer::SQLiteIDBBackingStore::deleteUnusedBlobFileRecords):
(WebCore::IDBServer::SQLiteIDBBackingStore::deleteRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::deleteRange):
(WebCore::IDBServer::SQLiteIDBBackingStore::updateAllIndexesForAddRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::addRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::getBlobRecordsForObjectStoreRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::getRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::getAllObjectStoreRecords):
(WebCore::IDBServer::SQLiteIDBBackingStore::getAllIndexRecords):
(WebCore::IDBServer::SQLiteIDBBackingStore::getIndexRecord):
(WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedGetIndexRecordForOneKey):
(WebCore::IDBServer::SQLiteIDBBackingStore::getCount):
(WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedGetKeyGeneratorValue):
(WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedSetKeyGeneratorValue):
(WebCore::IDBServer::SQLiteIDBBackingStore::generateKeyNumber):
(WebCore::IDBServer::SQLiteIDBBackingStore::revertGeneratedKeyNumber):
(WebCore::IDBServer::SQLiteIDBBackingStore::maybeUpdateKeyGeneratorNumber):
(WebCore::IDBServer::SQLiteIDBBackingStore::openCursor):
(WebCore::IDBServer::SQLiteIDBBackingStore::iterateCursor):
* Modules/indexeddb/server/SQLiteIDBTransaction.cpp:
(WebCore::IDBServer::SQLiteIDBTransaction::begin):
(WebCore::IDBServer::SQLiteIDBTransaction::commit):
(WebCore::IDBServer::SQLiteIDBTransaction::abort):
* Modules/indexeddb/server/UniqueIDBDatabase.cpp:
(WebCore::IDBServer::UniqueIDBDatabase::performCurrentOpenOperation):
(WebCore::IDBServer::UniqueIDBDatabase::deleteObjectStore):
(WebCore::IDBServer::UniqueIDBDatabase::renameObjectStore):
(WebCore::IDBServer::UniqueIDBDatabase::deleteIndex):
(WebCore::IDBServer::UniqueIDBDatabase::renameIndex):
(WebCore::IDBServer::UniqueIDBDatabase::performPutOrAdd):
(WebCore::IDBServer::UniqueIDBDatabase::commitTransaction):
(WebCore::IDBServer::UniqueIDBDatabase::abortTransaction):
* Modules/indexeddb/shared/IDBError.cpp:
(WebCore::IDBError::name):
(WebCore::IDBError::message):
(WebCore::IDBError::toDOMError):
* Modules/indexeddb/shared/IDBError.h:
(WebCore::IDBError::userDeleteError):
(WebCore::IDBError::isNull):
* WebCore.xcodeproj/project.pbxproj:
* bindings/js/JSDOMExceptionHandling.cpp:
(WebCore::createDOMException):

* dom/DOMException.cpp:
(WebCore::DOMException::initializeDescription):
Initialize description->code from using the actual error codes in the
coreExceptions table, instead of initializing it using |ec|. |ec| is
the index in the ExceptionCode enumeration and it matches the error
code only for legacy exceptions. New exceptions such as DataError
should have a code of 0. Without this change, w3c for IDB would start
failing.

* dom/ExceptionCodeDescription.cpp:
(WebCore::ExceptionCodeDescription::ExceptionCodeDescription):
* dom/ExceptionCodeDescription.h:

Source/WebKit:

* WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
(WebKit::WebIDBConnectionToServer::connectionToServerLost):

LayoutTests:

Rebaseline test as the exception messages are slightly different.

* storage/indexeddb/createIndex-after-failure-expected.txt:
* storage/indexeddb/createIndex-after-failure-private-expected.txt:
* storage/indexeddb/get-keyrange-expected.txt:
* storage/indexeddb/get-keyrange-private-expected.txt:
* storage/indexeddb/keypath-edges-expected.txt:
* storage/indexeddb/keypath-edges-private-expected.txt:
* storage/indexeddb/keyrange-expected.txt:
* storage/indexeddb/keyrange-private-expected.txt:
* storage/indexeddb/modern/idbdatabase-deleteobjectstore-failures-expected.txt:
* storage/indexeddb/modern/idbdatabase-deleteobjectstore-failures-private-expected.txt:
* storage/indexeddb/transaction-active-flag-expected.txt:
* storage/indexeddb/transaction-active-flag-private-expected.txt:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@219758 268f45cc-cd09-0410-ab3c-d52691b4dbfc

49 files changed:
LayoutTests/ChangeLog
LayoutTests/imported/w3c/ChangeLog
LayoutTests/imported/w3c/web-platform-tests/IndexedDB/keypath-special-identifiers-expected.txt
LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/derive_bits_keys/test_ecdh_bits.https-expected.txt
LayoutTests/imported/w3c/web-platform-tests/WebCryptoAPI/derive_bits_keys/test_ecdh_keys.https-expected.txt
LayoutTests/imported/w3c/web-platform-tests/webrtc/RTCPeerConnection-addIceCandidate-expected.txt
LayoutTests/storage/indexeddb/createIndex-after-failure-expected.txt
LayoutTests/storage/indexeddb/createIndex-after-failure-private-expected.txt
LayoutTests/storage/indexeddb/get-keyrange-expected.txt
LayoutTests/storage/indexeddb/get-keyrange-private-expected.txt
LayoutTests/storage/indexeddb/keypath-edges-expected.txt
LayoutTests/storage/indexeddb/keypath-edges-private-expected.txt
LayoutTests/storage/indexeddb/keyrange-expected.txt
LayoutTests/storage/indexeddb/keyrange-private-expected.txt
LayoutTests/storage/indexeddb/modern/idbdatabase-deleteobjectstore-failures-expected.txt
LayoutTests/storage/indexeddb/modern/idbdatabase-deleteobjectstore-failures-private-expected.txt
LayoutTests/storage/indexeddb/transaction-active-flag-expected.txt
LayoutTests/storage/indexeddb/transaction-active-flag-private-expected.txt
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog
Source/WebCore/Modules/indexeddb/IDBCursor.cpp
Source/WebCore/Modules/indexeddb/IDBDatabase.cpp
Source/WebCore/Modules/indexeddb/IDBDatabaseError.h [deleted file]
Source/WebCore/Modules/indexeddb/IDBDatabaseException.cpp [deleted file]
Source/WebCore/Modules/indexeddb/IDBDatabaseException.h [deleted file]
Source/WebCore/Modules/indexeddb/IDBFactory.cpp
Source/WebCore/Modules/indexeddb/IDBIndex.cpp
Source/WebCore/Modules/indexeddb/IDBKeyRange.cpp
Source/WebCore/Modules/indexeddb/IDBObjectStore.cpp
Source/WebCore/Modules/indexeddb/IDBOpenDBRequest.cpp
Source/WebCore/Modules/indexeddb/IDBRequest.cpp
Source/WebCore/Modules/indexeddb/IDBTransaction.cpp
Source/WebCore/Modules/indexeddb/server/IndexValueStore.cpp
Source/WebCore/Modules/indexeddb/server/MemoryIDBBackingStore.cpp
Source/WebCore/Modules/indexeddb/server/MemoryIndex.cpp
Source/WebCore/Modules/indexeddb/server/MemoryObjectStore.cpp
Source/WebCore/Modules/indexeddb/server/SQLiteIDBBackingStore.cpp
Source/WebCore/Modules/indexeddb/server/SQLiteIDBTransaction.cpp
Source/WebCore/Modules/indexeddb/server/UniqueIDBDatabase.cpp
Source/WebCore/Modules/indexeddb/shared/IDBError.cpp
Source/WebCore/Modules/indexeddb/shared/IDBError.h
Source/WebCore/WebCore.xcodeproj/project.pbxproj
Source/WebCore/bindings/js/JSDOMExceptionHandling.cpp
Source/WebCore/dom/DOMException.cpp
Source/WebCore/dom/DOMException.h
Source/WebCore/dom/ExceptionCodeDescription.cpp
Source/WebCore/dom/ExceptionCodeDescription.h
Source/WebKit/ChangeLog
Source/WebKit/WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp

index 1be59fd..0c0a868 100644 (file)
@@ -1,3 +1,25 @@
+2017-07-21  Chris Dumez  <cdumez@apple.com>
+
+        Drop IDBDatabaseException class
+        https://bugs.webkit.org/show_bug.cgi?id=174743
+
+        Reviewed by Darin Adler.
+
+        Rebaseline test as the exception messages are slightly different.
+
+        * storage/indexeddb/createIndex-after-failure-expected.txt:
+        * storage/indexeddb/createIndex-after-failure-private-expected.txt:
+        * storage/indexeddb/get-keyrange-expected.txt:
+        * storage/indexeddb/get-keyrange-private-expected.txt:
+        * storage/indexeddb/keypath-edges-expected.txt:
+        * storage/indexeddb/keypath-edges-private-expected.txt:
+        * storage/indexeddb/keyrange-expected.txt:
+        * storage/indexeddb/keyrange-private-expected.txt:
+        * storage/indexeddb/modern/idbdatabase-deleteobjectstore-failures-expected.txt:
+        * storage/indexeddb/modern/idbdatabase-deleteobjectstore-failures-private-expected.txt:
+        * storage/indexeddb/transaction-active-flag-expected.txt:
+        * storage/indexeddb/transaction-active-flag-private-expected.txt:
+
 2017-07-21  Per Arne Vollan  <pvollan@apple.com>
 
         Round-tripping stroke-width styles through getComputedStyle cause the text to gain a stroke.
index 9393173..934150c 100644 (file)
@@ -1,3 +1,14 @@
+2017-07-21  Chris Dumez  <cdumez@apple.com>
+
+        Drop IDBDatabaseException class
+        https://bugs.webkit.org/show_bug.cgi?id=174743
+
+        Reviewed by Darin Adler.
+
+        Rebaseline test as the exception message is slightly different.
+
+        * web-platform-tests/IndexedDB/keypath-special-identifiers-expected.txt:
+
 2017-07-20  Chris Dumez  <cdumez@apple.com>
 
         Unreviewed, rebaseline test after r219663.
index af2d6b5..d27b7c3 100644 (file)
@@ -5,5 +5,5 @@ PASS Type: Blob, identifier: size
 PASS Type: Blob, identifier: type 
 PASS Type: File, identifier: name 
 FAIL Type: File, identifier: lastModified assert_equals: Property should be used as key expected 0 but got 1
-FAIL Type: File, identifier: lastModifiedDate The data provided does not meet requirements.
+FAIL Type: File, identifier: lastModifiedDate Provided data is inadequate.
 
index 9f45ebb..43fd64a 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 198: Unhandled Promise Rejection: DataError (DOM Exception 30): Data provided to an operation does not meet requirements
+CONSOLE MESSAGE: line 198: Unhandled Promise Rejection: DataError (DOM Exception): Data provided to an operation does not meet requirements
 deriveBits Tests for ECDH
 
 
index 0e37d46..994a803 100644 (file)
@@ -1,4 +1,4 @@
-CONSOLE MESSAGE: line 167: Unhandled Promise Rejection: DataError (DOM Exception 30): Data provided to an operation does not meet requirements
+CONSOLE MESSAGE: line 167: Unhandled Promise Rejection: DataError (DOM Exception): Data provided to an operation does not meet requirements
 deriveKey Tests for ECDH
 
 
index 39b81a3..f2bcac0 100644 (file)
@@ -1,7 +1,7 @@
-CONSOLE MESSAGE: Unhandled Promise Rejection: OperationError (DOM Exception 34): Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
-CONSOLE MESSAGE: Unhandled Promise Rejection: OperationError (DOM Exception 34): Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
-CONSOLE MESSAGE: Unhandled Promise Rejection: OperationError (DOM Exception 34): Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
-CONSOLE MESSAGE: Unhandled Promise Rejection: OperationError (DOM Exception 34): Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
+CONSOLE MESSAGE: Unhandled Promise Rejection: OperationError (DOM Exception): Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
+CONSOLE MESSAGE: Unhandled Promise Rejection: OperationError (DOM Exception): Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
+CONSOLE MESSAGE: Unhandled Promise Rejection: OperationError (DOM Exception): Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
+CONSOLE MESSAGE: Unhandled Promise Rejection: OperationError (DOM Exception): Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
 
 Harness Error (FAIL), message = Failed to set remote offer sdp: Session error code: ERROR_CONTENT. Session error description: Failed to set remote video description send parameters..
 
index f1a1df0..69d6ee2 100644 (file)
@@ -16,8 +16,8 @@ PASS ename is 'NotFoundError'
 Exception message: Failed to execute 'deleteIndex' on 'IDBObjectStore': The specified index was not found.
 Now requesting object2
 now we wait.
-Error function called: (AbortError) The transaction was aborted, so the request cannot be fulfilled.
-PASS Abort function called: (ConstraintError) A mutation operation in the transaction failed because a constraint was not satisfied.
+Error function called: (AbortError) The operation was aborted.
+PASS Abort function called: (ConstraintError) A mutation operation in a transaction failed because a constraint was not satisfied.
 PASS successfullyParsed is true
 
 TEST COMPLETE
index f1a1df0..69d6ee2 100644 (file)
@@ -16,8 +16,8 @@ PASS ename is 'NotFoundError'
 Exception message: Failed to execute 'deleteIndex' on 'IDBObjectStore': The specified index was not found.
 Now requesting object2
 now we wait.
-Error function called: (AbortError) The transaction was aborted, so the request cannot be fulfilled.
-PASS Abort function called: (ConstraintError) A mutation operation in the transaction failed because a constraint was not satisfied.
+Error function called: (AbortError) The operation was aborted.
+PASS Abort function called: (ConstraintError) A mutation operation in a transaction failed because a constraint was not satisfied.
 PASS successfullyParsed is true
 
 TEST COMPLETE
index da558ae..9a72f8d 100644 (file)
@@ -40,7 +40,7 @@ Expecting exception from objectStore.get(null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 runIndexStoreTests()
 index.get(IDBKeyRange.only(3))
 PASS result.x is 3
@@ -62,7 +62,7 @@ Expecting exception from index.get(null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 runIndexKeyTests()
 index.getKey(IDBKeyRange.only(3))
 PASS result is 3
@@ -84,7 +84,7 @@ Expecting exception from index.getKey(null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 finishJSTest()
 PASS successfullyParsed is true
 
index da558ae..9a72f8d 100644 (file)
@@ -40,7 +40,7 @@ Expecting exception from objectStore.get(null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 runIndexStoreTests()
 index.get(IDBKeyRange.only(3))
 PASS result.x is 3
@@ -62,7 +62,7 @@ Expecting exception from index.get(null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 runIndexKeyTests()
 index.getKey(IDBKeyRange.only(3))
 PASS result is 3
@@ -84,7 +84,7 @@ Expecting exception from index.getKey(null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 finishJSTest()
 PASS successfullyParsed is true
 
index 59c1664..bfdb0b6 100644 (file)
@@ -48,14 +48,14 @@ Expecting exception from store.put(null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 
 Key path doesn't resolve to a value; should yield null but insertion would fail, so put request should raise exception
 Expecting exception from store.put('string')
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 
 Key path doesn't resolve to a value; should yield null, key should be generated, put request should succeed
 store.put({})
index 59c1664..bfdb0b6 100644 (file)
@@ -48,14 +48,14 @@ Expecting exception from store.put(null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 
 Key path doesn't resolve to a value; should yield null but insertion would fail, so put request should raise exception
 Expecting exception from store.put('string')
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 
 Key path doesn't resolve to a value; should yield null, key should be generated, put request should succeed
 store.put({})
index 6f72ca6..2fe0d49 100644 (file)
@@ -311,61 +311,61 @@ Expecting exception from IDBKeyRange.only({})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into upperBound({})
 Expecting exception from IDBKeyRange.upperBound({})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into lowerBound({})
 Expecting exception from IDBKeyRange.lowerBound({})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into bound(null, {})
 Expecting exception from IDBKeyRange.bound(null, {})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into bound({},null)
 Expecting exception from IDBKeyRange.bound({}, null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into bound({}, {})
 Expecting exception from IDBKeyRange.bound({}, {})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Lower key greater than higher key, bound(4, 3)
 Expecting exception from IDBKeyRange.bound(4, 3)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Equal keys, either of the bounds is open, bound(4, 4, true, false)
 Expecting exception from IDBKeyRange.bound(4, 4, true, false)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Equal keys, either of the bounds is open, bound(4, 4, false, true)
 Expecting exception from IDBKeyRange.bound(4, 4, false, true)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Equal keys, either of the bounds is open, bound(4, 4, true, true)
 Expecting exception from IDBKeyRange.bound(4, 4, true, true)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Equal keys, none of the bounds is open, bound(4, 4, false, false)
 Passing an invalid key in to IDBKeyRange.includes({})
 Expecting exception from invalidKeyKeyRange.includes({})
index 6f72ca6..2fe0d49 100644 (file)
@@ -311,61 +311,61 @@ Expecting exception from IDBKeyRange.only({})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into upperBound({})
 Expecting exception from IDBKeyRange.upperBound({})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into lowerBound({})
 Expecting exception from IDBKeyRange.lowerBound({})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into bound(null, {})
 Expecting exception from IDBKeyRange.bound(null, {})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into bound({},null)
 Expecting exception from IDBKeyRange.bound({}, null)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Passing an invalid key into bound({}, {})
 Expecting exception from IDBKeyRange.bound({}, {})
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Lower key greater than higher key, bound(4, 3)
 Expecting exception from IDBKeyRange.bound(4, 3)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Equal keys, either of the bounds is open, bound(4, 4, true, false)
 Expecting exception from IDBKeyRange.bound(4, 4, true, false)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Equal keys, either of the bounds is open, bound(4, 4, false, true)
 Expecting exception from IDBKeyRange.bound(4, 4, false, true)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Equal keys, either of the bounds is open, bound(4, 4, true, true)
 Expecting exception from IDBKeyRange.bound(4, 4, true, true)
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'DataError'
-Exception message: The data provided does not meet requirements.
+Exception message: Provided data is inadequate.
 Equal keys, none of the bounds is open, bound(4, 4, false, false)
 Passing an invalid key in to IDBKeyRange.includes({})
 Expecting exception from invalidKeyKeyRange.includes({})
index 91e1724..6143901 100644 (file)
@@ -14,7 +14,7 @@ Failed to deleteObjectStore without a versionchange transaction - InvalidStateEr
 readwrite transaction complete
 Second upgrade needed: Old version - 1 New version - 2
 Failed to deleteObjectStore with a non-existent objectstore - NotFoundError: Failed to execute 'deleteObjectStore' on 'IDBDatabase': The specified object store was not found.
-Failed to deleteObjectStore with an in-progress versionchange transaction that is inactive - TransactionInactiveError: A request was placed against a transaction which is either currently not active, or which is finished.
+Failed to deleteObjectStore with an in-progress versionchange transaction that is inactive - TransactionInactiveError: A request was placed against a transaction which is currently not active, or which is finished.
 Second version change transaction complete
 PASS successfullyParsed is true
 
index 91e1724..6143901 100644 (file)
@@ -14,7 +14,7 @@ Failed to deleteObjectStore without a versionchange transaction - InvalidStateEr
 readwrite transaction complete
 Second upgrade needed: Old version - 1 New version - 2
 Failed to deleteObjectStore with a non-existent objectstore - NotFoundError: Failed to execute 'deleteObjectStore' on 'IDBDatabase': The specified object store was not found.
-Failed to deleteObjectStore with an in-progress versionchange transaction that is inactive - TransactionInactiveError: A request was placed against a transaction which is either currently not active, or which is finished.
+Failed to deleteObjectStore with an in-progress versionchange transaction that is inactive - TransactionInactiveError: A request was placed against a transaction which is currently not active, or which is finished.
 Second version change transaction complete
 PASS successfullyParsed is true
 
index 3af3bf2..602e9fd 100644 (file)
@@ -74,7 +74,7 @@ Expecting exception from store.get(IDBKeyRange.only(0))
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'TransactionInactiveError'
-Exception message: A request was placed against a transaction which is either currently not active, or which is finished.
+Exception message: A request was placed against a transaction which is currently not active, or which is finished.
 Expecting exception from store.delete(0)
 PASS Exception was thrown.
 PASS code is 0
index 3af3bf2..602e9fd 100644 (file)
@@ -74,7 +74,7 @@ Expecting exception from store.get(IDBKeyRange.only(0))
 PASS Exception was thrown.
 PASS code is 0
 PASS ename is 'TransactionInactiveError'
-Exception message: A request was placed against a transaction which is either currently not active, or which is finished.
+Exception message: A request was placed against a transaction which is currently not active, or which is finished.
 Expecting exception from store.delete(0)
 PASS Exception was thrown.
 PASS code is 0
index 1ea7535..b23a8e5 100644 (file)
@@ -891,7 +891,6 @@ set(WebCore_SOURCES
     Modules/indexeddb/IDBCursor.cpp
     Modules/indexeddb/IDBCursorWithValue.cpp
     Modules/indexeddb/IDBDatabase.cpp
-    Modules/indexeddb/IDBDatabaseException.cpp
     Modules/indexeddb/IDBDatabaseIdentifier.cpp
     Modules/indexeddb/IDBEventDispatcher.cpp
     Modules/indexeddb/IDBFactory.cpp
index c5462b6..5e8b613 100644 (file)
@@ -1,3 +1,179 @@
+2017-07-21  Chris Dumez  <cdumez@apple.com>
+
+        Drop IDBDatabaseException class
+        https://bugs.webkit.org/show_bug.cgi?id=174743
+
+        Reviewed by Darin Adler.
+
+        Drop IDBDatabaseException class and use DOMException directly. IDBDatabaseException was
+        only an internal concept and was already exposed to the Web as a DOMException. This
+        simplifies the code a bit and will allow for further simplification in a follow-up patch.
+
+        No new tests, no Web-facing behavior change, except for some exception messages
+        being slightly different.
+
+        * CMakeLists.txt:
+        * Modules/indexeddb/IDBCursor.cpp:
+        (WebCore::IDBCursor::update):
+        (WebCore::IDBCursor::advance):
+        (WebCore::IDBCursor::continuePrimaryKey):
+        (WebCore::IDBCursor::continueFunction):
+        (WebCore::IDBCursor::deleteFunction):
+        * Modules/indexeddb/IDBDatabase.cpp:
+        (WebCore::IDBDatabase::createObjectStore):
+        (WebCore::IDBDatabase::transaction):
+        (WebCore::IDBDatabase::deleteObjectStore):
+        * Modules/indexeddb/IDBDatabaseError.h: Removed.
+        * Modules/indexeddb/IDBDatabaseException.cpp: Removed.
+        * Modules/indexeddb/IDBDatabaseException.h: Removed.
+        * Modules/indexeddb/IDBFactory.cpp:
+        (WebCore::IDBFactory::cmp):
+        * Modules/indexeddb/IDBIndex.cpp:
+        (WebCore::IDBIndex::setName):
+        (WebCore::IDBIndex::openCursor):
+        (WebCore::IDBIndex::openKeyCursor):
+        (WebCore::IDBIndex::count):
+        (WebCore::IDBIndex::doCount):
+        (WebCore::IDBIndex::get):
+        (WebCore::IDBIndex::doGet):
+        (WebCore::IDBIndex::getKey):
+        (WebCore::IDBIndex::doGetKey):
+        (WebCore::IDBIndex::getAll):
+        (WebCore::IDBIndex::getAllKeys):
+        * Modules/indexeddb/IDBKeyRange.cpp:
+        (WebCore::IDBKeyRange::only):
+        (WebCore::IDBKeyRange::lowerBound):
+        (WebCore::IDBKeyRange::upperBound):
+        (WebCore::IDBKeyRange::bound):
+        (WebCore::IDBKeyRange::includes):
+        * Modules/indexeddb/IDBObjectStore.cpp:
+        (WebCore::IDBObjectStore::setName):
+        (WebCore::IDBObjectStore::openCursor):
+        (WebCore::IDBObjectStore::openKeyCursor):
+        (WebCore::IDBObjectStore::get):
+        (WebCore::IDBObjectStore::getKey):
+        (WebCore::IDBObjectStore::putOrAdd):
+        (WebCore::IDBObjectStore::doDelete):
+        (WebCore::IDBObjectStore::deleteFunction):
+        (WebCore::IDBObjectStore::clear):
+        (WebCore::IDBObjectStore::createIndex):
+        (WebCore::IDBObjectStore::index):
+        (WebCore::IDBObjectStore::deleteIndex):
+        (WebCore::IDBObjectStore::count):
+        (WebCore::IDBObjectStore::doCount):
+        (WebCore::IDBObjectStore::getAll):
+        (WebCore::IDBObjectStore::getAllKeys):
+        * Modules/indexeddb/IDBOpenDBRequest.cpp:
+        (WebCore::IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion):
+        * Modules/indexeddb/IDBRequest.cpp:
+        (WebCore::IDBRequest::result):
+        (WebCore::IDBRequest::error):
+        (WebCore::IDBRequest::uncaughtExceptionInEventHandler):
+        * Modules/indexeddb/IDBTransaction.cpp:
+        (WebCore::IDBTransaction::objectStore):
+        (WebCore::IDBTransaction::abort):
+        (WebCore::IDBTransaction::abortOnServerAndCancelRequests):
+        (WebCore::IDBTransaction::didCreateIndexOnServer):
+        (WebCore::IDBTransaction::putOrAddOnServer):
+        * Modules/indexeddb/server/IndexValueStore.cpp:
+        (WebCore::IDBServer::IndexValueStore::addRecord):
+        * Modules/indexeddb/server/MemoryIDBBackingStore.cpp:
+        (WebCore::IDBServer::MemoryIDBBackingStore::beginTransaction):
+        (WebCore::IDBServer::MemoryIDBBackingStore::abortTransaction):
+        (WebCore::IDBServer::MemoryIDBBackingStore::commitTransaction):
+        (WebCore::IDBServer::MemoryIDBBackingStore::createObjectStore):
+        (WebCore::IDBServer::MemoryIDBBackingStore::deleteObjectStore):
+        (WebCore::IDBServer::MemoryIDBBackingStore::renameObjectStore):
+        (WebCore::IDBServer::MemoryIDBBackingStore::clearObjectStore):
+        (WebCore::IDBServer::MemoryIDBBackingStore::createIndex):
+        (WebCore::IDBServer::MemoryIDBBackingStore::deleteIndex):
+        (WebCore::IDBServer::MemoryIDBBackingStore::renameIndex):
+        (WebCore::IDBServer::MemoryIDBBackingStore::deleteRange):
+        (WebCore::IDBServer::MemoryIDBBackingStore::addRecord):
+        (WebCore::IDBServer::MemoryIDBBackingStore::getRecord):
+        (WebCore::IDBServer::MemoryIDBBackingStore::getAllRecords):
+        (WebCore::IDBServer::MemoryIDBBackingStore::getIndexRecord):
+        (WebCore::IDBServer::MemoryIDBBackingStore::getCount):
+        (WebCore::IDBServer::MemoryIDBBackingStore::generateKeyNumber):
+        (WebCore::IDBServer::MemoryIDBBackingStore::openCursor):
+        (WebCore::IDBServer::MemoryIDBBackingStore::iterateCursor):
+        * Modules/indexeddb/server/MemoryIndex.cpp:
+        (WebCore::IDBServer::MemoryIndex::putIndexKey):
+        * Modules/indexeddb/server/MemoryObjectStore.cpp:
+        (WebCore::IDBServer::MemoryObjectStore::createIndex):
+        (WebCore::IDBServer::MemoryObjectStore::deleteIndex):
+        * Modules/indexeddb/server/SQLiteIDBBackingStore.cpp:
+        (WebCore::IDBServer::SQLiteIDBBackingStore::getOrEstablishDatabaseInfo):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::beginTransaction):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::abortTransaction):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::commitTransaction):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::createObjectStore):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::deleteObjectStore):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::renameObjectStore):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::clearObjectStore):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::createIndex):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedHasIndexRecord):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedPutIndexKey):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedPutIndexRecord):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::deleteIndex):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::renameIndex):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::keyExistsInObjectStore):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::deleteUnusedBlobFileRecords):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::deleteRecord):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::deleteRange):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::updateAllIndexesForAddRecord):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::addRecord):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::getBlobRecordsForObjectStoreRecord):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::getRecord):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::getAllObjectStoreRecords):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::getAllIndexRecords):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::getIndexRecord):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedGetIndexRecordForOneKey):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::getCount):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedGetKeyGeneratorValue):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::uncheckedSetKeyGeneratorValue):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::generateKeyNumber):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::revertGeneratedKeyNumber):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::maybeUpdateKeyGeneratorNumber):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::openCursor):
+        (WebCore::IDBServer::SQLiteIDBBackingStore::iterateCursor):
+        * Modules/indexeddb/server/SQLiteIDBTransaction.cpp:
+        (WebCore::IDBServer::SQLiteIDBTransaction::begin):
+        (WebCore::IDBServer::SQLiteIDBTransaction::commit):
+        (WebCore::IDBServer::SQLiteIDBTransaction::abort):
+        * Modules/indexeddb/server/UniqueIDBDatabase.cpp:
+        (WebCore::IDBServer::UniqueIDBDatabase::performCurrentOpenOperation):
+        (WebCore::IDBServer::UniqueIDBDatabase::deleteObjectStore):
+        (WebCore::IDBServer::UniqueIDBDatabase::renameObjectStore):
+        (WebCore::IDBServer::UniqueIDBDatabase::deleteIndex):
+        (WebCore::IDBServer::UniqueIDBDatabase::renameIndex):
+        (WebCore::IDBServer::UniqueIDBDatabase::performPutOrAdd):
+        (WebCore::IDBServer::UniqueIDBDatabase::commitTransaction):
+        (WebCore::IDBServer::UniqueIDBDatabase::abortTransaction):
+        * Modules/indexeddb/shared/IDBError.cpp:
+        (WebCore::IDBError::name):
+        (WebCore::IDBError::message):
+        (WebCore::IDBError::toDOMError):
+        * Modules/indexeddb/shared/IDBError.h:
+        (WebCore::IDBError::userDeleteError):
+        (WebCore::IDBError::isNull):
+        * WebCore.xcodeproj/project.pbxproj:
+        * bindings/js/JSDOMExceptionHandling.cpp:
+        (WebCore::createDOMException):
+
+        * dom/DOMException.cpp:
+        (WebCore::DOMException::initializeDescription):
+        Initialize description->code from using the actual error codes in the
+        coreExceptions table, instead of initializing it using |ec|. |ec| is
+        the index in the ExceptionCode enumeration and it matches the error
+        code only for legacy exceptions. New exceptions such as DataError
+        should have a code of 0. Without this change, w3c for IDB would start
+        failing.
+
+        * dom/ExceptionCodeDescription.cpp:
+        (WebCore::ExceptionCodeDescription::ExceptionCodeDescription):
+        * dom/ExceptionCodeDescription.h:
+
 2017-07-21  Sam Weinig  <sam@webkit.org>
 
         [WebIDL] Simplify XMLHttpRequest bindings by removing built-ins
index 7f490e9..3f930ed 100644 (file)
@@ -31,7 +31,6 @@
 #include "ExceptionCode.h"
 #include "IDBBindingUtilities.h"
 #include "IDBDatabase.h"
-#include "IDBDatabaseException.h"
 #include "IDBGetResult.h"
 #include "IDBIndex.h"
 #include "IDBIterateCursorData.h"
@@ -113,19 +112,19 @@ ExceptionOr<Ref<IDBRequest>> IDBCursor::update(ExecState& state, JSValue value)
     ASSERT(currentThread() == effectiveObjectStore().transaction().database().originThreadID());
 
     if (sourcesDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
 
     if (!transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The transaction is inactive or finished.") };
 
     if (transaction().isReadOnly())
-        return Exception { IDBDatabaseException::ReadOnlyError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The record may not be updated inside a read-only transaction.") };
+        return Exception { ReadonlyError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The record may not be updated inside a read-only transaction.") };
 
     if (!m_gotValue)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
 
     if (!isKeyCursorWithValue())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The cursor is a key cursor.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The cursor is a key cursor.") };
 
     auto& objectStore = effectiveObjectStore();
     auto& optionalKeyPath = objectStore.info().keyPath();
@@ -134,7 +133,7 @@ ExceptionOr<Ref<IDBRequest>> IDBCursor::update(ExecState& state, JSValue value)
         RefPtr<IDBKey> keyPathKey = maybeCreateIDBKeyFromScriptValueAndKeyPath(state, value, optionalKeyPath.value());
         IDBKeyData keyPathKeyData(keyPathKey.get());
         if (!keyPathKey || keyPathKeyData != m_currentPrimaryKeyData)
-            return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The effective object store of this cursor uses in-line keys and evaluating the key path of the value parameter results in a different value than the cursor's effective key.") };
+            return Exception { DataError, ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The effective object store of this cursor uses in-line keys and evaluating the key path of the value parameter results in a different value than the cursor's effective key.") };
     }
 
     auto putResult = effectiveObjectStore().putForCursorUpdate(state, value, m_currentPrimaryKey.get());
@@ -154,19 +153,19 @@ ExceptionOr<void> IDBCursor::advance(unsigned count)
     ASSERT(currentThread() == effectiveObjectStore().transaction().database().originThreadID());
 
     if (!m_request)
-        return Exception { IDBDatabaseException::InvalidStateError };
+        return Exception { INVALID_STATE_ERR };
 
     if (!count)
         return Exception { TypeError, ASCIILiteral("Failed to execute 'advance' on 'IDBCursor': A count argument with value 0 (zero) was supplied, must be greater than 0.") };
 
     if (!transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'advance' on 'IDBCursor': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'advance' on 'IDBCursor': The transaction is inactive or finished.") };
 
     if (sourcesDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'advance' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'advance' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
 
     if (!m_gotValue)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'advance' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'advance' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
 
     m_gotValue = false;
 
@@ -178,43 +177,43 @@ ExceptionOr<void> IDBCursor::advance(unsigned count)
 ExceptionOr<void> IDBCursor::continuePrimaryKey(ExecState& state, JSValue keyValue, JSValue primaryKeyValue)
 {
     if (!transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The transaction is inactive or finished.") };
 
     if (sourcesDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
 
     if (!WTF::holds_alternative<RefPtr<IDBIndex>>(m_source))
-        return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The cursor's source is not an index.") };
+        return Exception { INVALID_ACCESS_ERR, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The cursor's source is not an index.") };
 
     auto direction = m_info.cursorDirection();
     if (direction != IndexedDB::CursorDirection::Next && direction != IndexedDB::CursorDirection::Prev)
-        return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The cursor's direction must be either \"next\" or \"prev\".") };
+        return Exception { INVALID_ACCESS_ERR, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The cursor's direction must be either \"next\" or \"prev\".") };
 
     if (!m_gotValue)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
 
     RefPtr<IDBKey> key = scriptValueToIDBKey(state, keyValue);
     if (!key->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The first parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The first parameter is not a valid key.") };
 
     RefPtr<IDBKey> primaryKey = scriptValueToIDBKey(state, primaryKeyValue);
     if (!primaryKey->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The second parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The second parameter is not a valid key.") };
 
     IDBKeyData keyData = { key.get() };
     IDBKeyData primaryKeyData = { primaryKey.get() };
 
     if (keyData < m_currentKeyData && direction == IndexedDB::CursorDirection::Next)
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The first parameter is less than this cursor's position and this cursor's direction is \"next\".") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The first parameter is less than this cursor's position and this cursor's direction is \"next\".") };
 
     if (keyData > m_currentKeyData && direction == IndexedDB::CursorDirection::Prev)
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The first parameter is greater than this cursor's position and this cursor's direction is \"prev\".") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The first parameter is greater than this cursor's position and this cursor's direction is \"prev\".") };
 
     if (keyData == m_currentKeyData) {
         if (primaryKeyData <= m_currentPrimaryKeyData && direction == IndexedDB::CursorDirection::Next)
-            return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The key parameters represent a position less-than-or-equal-to this cursor's position and this cursor's direction is \"next\".") };
+            return Exception { DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The key parameters represent a position less-than-or-equal-to this cursor's position and this cursor's direction is \"next\".") };
         if (primaryKeyData >= m_currentPrimaryKeyData && direction == IndexedDB::CursorDirection::Prev)
-            return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The key parameters represent a position greater-than-or-equal-to this cursor's position and this cursor's direction is \"prev\".") };
+            return Exception { DataError, ASCIILiteral("Failed to execute 'continuePrimaryKey' on 'IDBCursor': The key parameters represent a position greater-than-or-equal-to this cursor's position and this cursor's direction is \"prev\".") };
     }
 
     m_gotValue = false;
@@ -239,26 +238,26 @@ ExceptionOr<void> IDBCursor::continueFunction(const IDBKeyData& key)
     ASSERT(currentThread() == effectiveObjectStore().transaction().database().originThreadID());
 
     if (!m_request)
-        return Exception { IDBDatabaseException::InvalidStateError };
+        return Exception { INVALID_STATE_ERR };
 
     if (!transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The transaction is inactive or finished.") };
 
     if (sourcesDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
 
     if (!m_gotValue)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
 
     if (!key.isNull() && !key.isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The parameter is not a valid key.") };
 
     if (m_info.isDirectionForward()) {
         if (!key.isNull() && key.compare(m_currentKeyData) <= 0)
-            return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The parameter is less than or equal to this cursor's position.") };
+            return Exception { DataError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The parameter is less than or equal to this cursor's position.") };
     } else {
         if (!key.isNull() && key.compare(m_currentKeyData) >= 0)
-            return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The parameter is greater than or equal to this cursor's position.") };
+            return Exception { DataError, ASCIILiteral("Failed to execute 'continue' on 'IDBCursor': The parameter is greater than or equal to this cursor's position.") };
     }
 
     m_gotValue = false;
@@ -294,19 +293,19 @@ ExceptionOr<Ref<WebCore::IDBRequest>> IDBCursor::deleteFunction(ExecState& state
     ASSERT(currentThread() == effectiveObjectStore().transaction().database().originThreadID());
 
     if (sourcesDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The cursor's source or effective object store has been deleted.") };
 
     if (!transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The transaction is inactive or finished.") };
 
     if (transaction().isReadOnly())
-        return Exception { IDBDatabaseException::ReadOnlyError, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The record may not be deleted inside a read-only transaction.") };
+        return Exception { ReadonlyError, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The record may not be deleted inside a read-only transaction.") };
 
     if (!m_gotValue)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The cursor is being iterated or has iterated past its end.") };
 
     if (!isKeyCursorWithValue())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The cursor is a key cursor.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The cursor is a key cursor.") };
 
     auto result = effectiveObjectStore().deleteFunction(state, m_currentPrimaryKey.get());
     if (result.hasException())
index fad585c..da05a3d 100644 (file)
@@ -34,7 +34,6 @@
 #include "ExceptionCode.h"
 #include "IDBConnectionProxy.h"
 #include "IDBConnectionToServer.h"
-#include "IDBDatabaseException.h"
 #include "IDBIndex.h"
 #include "IDBObjectStore.h"
 #include "IDBOpenDBRequest.h"
@@ -141,20 +140,20 @@ ExceptionOr<Ref<IDBObjectStore>> IDBDatabase::createObjectStore(const String& na
     ASSERT(!m_versionChangeTransaction || m_versionChangeTransaction->isVersionChange());
 
     if (!m_versionChangeTransaction)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The database is not running a version change transaction.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The database is not running a version change transaction.") };
 
     if (!m_versionChangeTransaction->isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError };
+        return Exception { TransactionInactiveError };
 
     if (m_info.hasObjectStore(name))
-        return Exception { IDBDatabaseException::ConstraintError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': An object store with the specified name already exists.") };
+        return Exception { ConstraintError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': An object store with the specified name already exists.") };
 
     auto& keyPath = parameters.keyPath;
     if (keyPath && !isIDBKeyPathValid(keyPath.value()))
-        return Exception { IDBDatabaseException::SyntaxError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The keyPath option is not a valid key path.") };
+        return Exception { SYNTAX_ERR, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The keyPath option is not a valid key path.") };
 
     if (keyPath && parameters.autoIncrement && ((WTF::holds_alternative<String>(keyPath.value()) && WTF::get<String>(keyPath.value()).isEmpty()) || WTF::holds_alternative<Vector<String>>(keyPath.value())))
-        return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The autoIncrement option was set but the keyPath option was empty or an array.") };
+        return Exception { INVALID_ACCESS_ERR, ASCIILiteral("Failed to execute 'createObjectStore' on 'IDBDatabase': The autoIncrement option was set but the keyPath option was empty or an array.") };
 
     // Install the new ObjectStore into the connection's metadata.
     auto info = m_info.createNewObjectStore(name, WTFMove(keyPath), parameters.autoIncrement);
@@ -170,7 +169,7 @@ ExceptionOr<Ref<IDBTransaction>> IDBDatabase::transaction(StringOrVectorOfString
     ASSERT(currentThread() == originThreadID());
 
     if (m_closePending)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The database connection is closing.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The database connection is closing.") };
 
     Vector<String> objectStores;
     if (WTF::holds_alternative<Vector<String>>(storeNames))
@@ -179,13 +178,13 @@ ExceptionOr<Ref<IDBTransaction>> IDBDatabase::transaction(StringOrVectorOfString
         objectStores.append(WTFMove(WTF::get<String>(storeNames)));
 
     if (objectStores.isEmpty())
-        return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The storeNames parameter was empty.") };
+        return Exception { INVALID_ACCESS_ERR, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': The storeNames parameter was empty.") };
 
     if (mode != IDBTransactionMode::Readonly && mode != IDBTransactionMode::Readwrite)
         return Exception { TypeError };
 
     if (m_versionChangeTransaction && !m_versionChangeTransaction->isFinishedOrFinishing())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': A version change transaction is running.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': A version change transaction is running.") };
 
     // It is valid for javascript to pass in a list of object store names with the same name listed twice,
     // so we need to put them all in a set to get a unique list.
@@ -199,7 +198,7 @@ ExceptionOr<Ref<IDBTransaction>> IDBDatabase::transaction(StringOrVectorOfString
     for (auto& objectStoreName : objectStores) {
         if (m_info.hasObjectStore(objectStoreName))
             continue;
-        return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': One of the specified object stores was not found.") };
+        return Exception { NOT_FOUND_ERR, ASCIILiteral("Failed to execute 'transaction' on 'IDBDatabase': One of the specified object stores was not found.") };
     }
 
     auto info = IDBTransactionInfo::clientTransaction(m_connectionProxy.get(), objectStores, mode);
@@ -221,13 +220,13 @@ ExceptionOr<void> IDBDatabase::deleteObjectStore(const String& objectStoreName)
     ASSERT(currentThread() == originThreadID());
 
     if (!m_versionChangeTransaction)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'deleteObjectStore' on 'IDBDatabase': The database is not running a version change transaction.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'deleteObjectStore' on 'IDBDatabase': The database is not running a version change transaction.") };
 
     if (!m_versionChangeTransaction->isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError };
+        return Exception { TransactionInactiveError };
 
     if (!m_info.hasObjectStore(objectStoreName))
-        return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'deleteObjectStore' on 'IDBDatabase': The specified object store was not found.") };
+        return Exception { NOT_FOUND_ERR, ASCIILiteral("Failed to execute 'deleteObjectStore' on 'IDBDatabase': The specified object store was not found.") };
 
     m_info.deleteObjectStore(objectStoreName);
     m_versionChangeTransaction->deleteObjectStore(objectStoreName);
diff --git a/Source/WebCore/Modules/indexeddb/IDBDatabaseError.h b/Source/WebCore/Modules/indexeddb/IDBDatabaseError.h
deleted file mode 100644 (file)
index a27cda6..0000000
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#pragma once
-
-#include "IDBDatabaseException.h"
-#include <wtf/RefCounted.h>
-#include <wtf/text/WTFString.h>
-
-#if ENABLE(INDEXED_DATABASE)
-
-namespace WebCore {
-
-class IDBDatabaseError : public RefCounted<IDBDatabaseError> {
-public:
-    static Ref<IDBDatabaseError> create(unsigned short code)
-    {
-        ASSERT(code >= IDBDatabaseException::IDBDatabaseExceptionOffset);
-        ASSERT(code < IDBDatabaseException::IDBDatabaseExceptionMax);
-        return adoptRef(*new IDBDatabaseError(code));
-    }
-
-    static Ref<IDBDatabaseError> create(unsigned short code, const String& message)
-    {
-        ASSERT_WITH_MESSAGE(code >= IDBDatabaseException::IDBDatabaseExceptionOffset, "%d >= %d", code, IDBDatabaseException::IDBDatabaseExceptionOffset);
-        ASSERT(code < IDBDatabaseException::IDBDatabaseExceptionMax);
-        return adoptRef(*new IDBDatabaseError(code, message));
-    }
-
-    ~IDBDatabaseError() { }
-
-    unsigned short code() const { return IDBDatabaseException::getLegacyErrorCode(m_code); }
-    unsigned short idbCode() const { return m_code; }
-    const String& message() const { return m_message; }
-    const String name() const { return IDBDatabaseException::getErrorName(m_code); };
-
-private:
-    IDBDatabaseError(unsigned short code)
-        : m_code(code), m_message(IDBDatabaseException::getErrorDescription(code)) { }
-    IDBDatabaseError(unsigned short code, const String& message)
-        : m_code(code), m_message(message) { }
-
-    const unsigned short m_code;
-    const String m_message;
-};
-
-} // namespace WebCore
-
-#endif // ENABLE(INDEXED_DATABASE)
diff --git a/Source/WebCore/Modules/indexeddb/IDBDatabaseException.cpp b/Source/WebCore/Modules/indexeddb/IDBDatabaseException.cpp
deleted file mode 100644 (file)
index 84ef23e..0000000
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * Copyright (C) 2011 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
- *     its contributors may be used to endorse or promote products derived
- *     from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY GOOGLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "config.h"
-#include "IDBDatabaseException.h"
-
-#if ENABLE(INDEXED_DATABASE)
-
-#include "ExceptionCode.h"
-#include "ExceptionCodeDescription.h"
-
-namespace WebCore {
-
-static const struct IDBDatabaseExceptionNameDescription {
-    const char* const name;
-    const char* const description;
-    const ExceptionCode code;
-} idbDatabaseExceptions[] = {
-    // These are IDB-specific errors from the spec.
-    { "UnknownError", "An unknown error occurred within Indexed Database.", 0 },
-    { "ConstraintError", "A mutation operation in the transaction failed because a constraint was not satisfied.", 0 },
-    { "DataError", "The data provided does not meet requirements.", 0 },
-    { "TransactionInactiveError", "A request was placed against a transaction which is either currently not active, or which is finished.", 0 },
-    { "ReadOnlyError", "A write operation was attempted in a read-only transaction.", 0 },
-    { "VersionError", "An attempt was made to open a database using a lower version than the existing version.", 0 },
-
-    // These are IDB-specific descriptions of generic DOM Exceptions when they are thrown from IDB APIs
-    { "NotFoundError", "An operation failed because the requested database object could not be found.", NOT_FOUND_ERR },
-    { "InvalidStateError", "An operation was called on an object on which it is not allowed or at a time when it is not allowed.", INVALID_STATE_ERR },
-    { "InvalidAccessError", "An invalid operation was performed on an object.", INVALID_ACCESS_ERR },
-    { "AbortError", "The transaction was aborted, so the request cannot be fulfilled.", ABORT_ERR },
-    { "TimeoutError", "A lock for the transaction could not be obtained in a reasonable time.", TIMEOUT_ERR }, // FIXME: This isn't used yet.
-    { "QuotaExceededError", "The operation failed because there was not enough remaining storage space, or the storage quota was reached and the user declined to give more space to the database.", QUOTA_EXCEEDED_ERR },
-    { "SyntaxError", "The keypath argument contains an invalid key path.", SYNTAX_ERR },
-    { "DataCloneError", "The data being stored could not be cloned by the internal structured cloning algorithm.", DATA_CLONE_ERR },
-};
-
-static const IDBDatabaseExceptionNameDescription* getErrorEntry(ExceptionCode ec)
-{
-    if (ec < IDBDatabaseException::IDBDatabaseExceptionOffset || ec > IDBDatabaseException::IDBDatabaseExceptionMax)
-        return 0;
-
-    size_t tableSize = WTF_ARRAY_LENGTH(idbDatabaseExceptions);
-    size_t tableIndex = ec - IDBDatabaseException::UnknownError;
-
-    return tableIndex < tableSize ? &idbDatabaseExceptions[tableIndex] : 0;
-}
-
-bool IDBDatabaseException::initializeDescription(ExceptionCode ec, ExceptionCodeDescription* description)
-{
-    const IDBDatabaseExceptionNameDescription* entry = getErrorEntry(ec);
-    if (!entry)
-        return false;
-
-    description->typeName = "DOM IDBDatabase";
-    description->code = entry->code;
-    description->type = IDBDatabaseExceptionType;
-
-    description->name = entry ? entry->name : 0;
-    description->description = entry ? entry->description : 0;
-
-    return true;
-}
-
-String IDBDatabaseException::getErrorName(ExceptionCode ec)
-{
-    const IDBDatabaseExceptionNameDescription* entry = getErrorEntry(ec);
-    ASSERT(entry);
-    if (!entry)
-        return ASCIILiteral("UnknownError");
-
-    return entry->name;
-}
-
-String IDBDatabaseException::getErrorDescription(ExceptionCode ec)
-{
-    const IDBDatabaseExceptionNameDescription* entry = getErrorEntry(ec);
-    ASSERT(entry);
-    if (!entry)
-        return ASCIILiteral("Unknown error.");
-
-    return entry->description;
-}
-
-ExceptionCode IDBDatabaseException::getLegacyErrorCode(ExceptionCode ec)
-{
-    const IDBDatabaseExceptionNameDescription* entry = getErrorEntry(ec);
-    ASSERT(entry);
-
-    return (entry && entry->code) ? entry->code : ec - IDBDatabaseExceptionOffset;
-}
-
-} // namespace WebCore
-
-#endif // ENABLE(INDEXED_DATABASE)
diff --git a/Source/WebCore/Modules/indexeddb/IDBDatabaseException.h b/Source/WebCore/Modules/indexeddb/IDBDatabaseException.h
deleted file mode 100644 (file)
index 9e0ce98..0000000
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1.  Redistributions of source code must retain the above copyright
- *     notice, this list of conditions and the following disclaimer.
- * 2.  Redistributions in binary form must reproduce the above copyright
- *     notice, this list of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#pragma once
-
-#if ENABLE(INDEXED_DATABASE)
-
-#include "ExceptionBase.h"
-
-namespace WebCore {
-
-class IDBDatabaseException : public ExceptionBase {
-public:
-    static Ref<IDBDatabaseException> create(const ExceptionCodeDescription& description)
-    {
-        return adoptRef(*new IDBDatabaseException(description));
-    }
-
-    static const int IDBDatabaseExceptionOffset = 1200;
-    static const int IDBDatabaseExceptionMax = 1299;
-
-    enum IDBDatabaseExceptionCode {
-        NoError = IDBDatabaseExceptionOffset,
-
-        // IndexedDB uses the following new DOMException types with their various messages:
-        UnknownError,
-        ConstraintError,
-        DataError,
-        TransactionInactiveError,
-        ReadOnlyError,
-        VersionError,
-
-        // IndexedDB reuses the following existing DOMException types, but with IDB-specific error messages.
-        NotFoundError,
-        InvalidStateError,
-        InvalidAccessError,
-        AbortError,
-        TimeoutError,
-        QuotaExceededError,
-        SyntaxError,
-        DataCloneError,
-    };
-
-    static int ErrorCodeToExceptionCode(int errorCode)
-    {
-        if (!errorCode)
-            return 0;
-        return errorCode + IDBDatabaseExceptionOffset;
-    }
-
-    static bool initializeDescription(ExceptionCode, ExceptionCodeDescription*);
-    static String getErrorName(ExceptionCode);
-    static String getErrorDescription(ExceptionCode);
-    static ExceptionCode getLegacyErrorCode(ExceptionCode);
-
-private:
-    IDBDatabaseException(const ExceptionCodeDescription& description)
-        : ExceptionBase(description)
-    {
-    }
-};
-
-} // namespace WebCore
-
-#endif // ENABLE(INDEXED_DATABASE)
index 6c67ecf..6003a3b 100644 (file)
@@ -129,7 +129,7 @@ ExceptionOr<short> IDBFactory::cmp(ExecState& execState, JSValue firstValue, JSV
     auto second = scriptValueToIDBKey(execState, secondValue);
 
     if (!first->isValid() || !second->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'cmp' on 'IDBFactory': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'cmp' on 'IDBFactory': The parameter is not a valid key.") };
 
     return first->compare(second.get());
 }
index 3ec5160..cd3f2dc 100644 (file)
@@ -32,7 +32,6 @@
 #include "IDBBindingUtilities.h"
 #include "IDBCursor.h"
 #include "IDBDatabase.h"
-#include "IDBDatabaseException.h"
 #include "IDBKeyRangeData.h"
 #include "IDBObjectStore.h"
 #include "IDBRequest.h"
@@ -95,13 +94,13 @@ ExceptionOr<void> IDBIndex::setName(const String& name)
         return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed set property 'name' on 'IDBIndex': The index's transaction is not a version change transaction.") };
 
     if (!m_objectStore.transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed set property 'name' on 'IDBIndex': The index's transaction is not active.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed set property 'name' on 'IDBIndex': The index's transaction is not active.") };
 
     if (m_info.name() == name)
         return { };
 
     if (m_objectStore.info().hasIndex(name))
-        return Exception { IDBDatabaseException::ConstraintError, makeString("Failed set property 'name' on 'IDBIndex': The owning object store already has an index named '", name, "'.") };
+        return Exception { ConstraintError, makeString("Failed set property 'name' on 'IDBIndex': The owning object store already has an index named '", name, "'.") };
 
     m_objectStore.transaction().database().renameIndex(*this, name);
     m_info.rename(name);
@@ -157,10 +156,10 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::openCursor(ExecState& execState, IDBKeyRa
     ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID());
 
     if (m_deleted || m_objectStore.isDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBIndex': The index or its object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'openCursor' on 'IDBIndex': The index or its object store has been deleted.") };
 
     if (!m_objectStore.transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBIndex': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBIndex': The transaction is inactive or finished.") };
 
     IDBKeyRangeData rangeData = range;
     if (rangeData.lowerKey.isNull())
@@ -179,7 +178,7 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::openCursor(ExecState& execState, JSValue
 
     auto keyRange = IDBKeyRange::only(execState, key);
     if (keyRange.hasException())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBIndex': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBIndex': The parameter is not a valid key.") };
 
     return openCursor(execState, keyRange.releaseReturnValue().ptr(), direction);
 }
@@ -190,10 +189,10 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::openKeyCursor(ExecState& execState, IDBKe
     ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID());
 
     if (m_deleted || m_objectStore.isDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBIndex': The index or its object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBIndex': The index or its object store has been deleted.") };
 
     if (!m_objectStore.transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBIndex': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBIndex': The transaction is inactive or finished.") };
 
     auto info = IDBCursorInfo::indexCursor(m_objectStore.transaction(), m_objectStore.info().identifier(), m_info.identifier(), range, direction, IndexedDB::CursorType::KeyOnly);
     return m_objectStore.transaction().requestOpenCursor(execState, *this, info);
@@ -205,7 +204,7 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::openKeyCursor(ExecState& execState, JSVal
 
     auto keyRange = IDBKeyRange::only(execState, key);
     if (keyRange.hasException())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBIndex': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBIndex': The parameter is not a valid key.") };
     return openKeyCursor(execState, keyRange.releaseReturnValue().ptr(), direction);
 }
 
@@ -222,7 +221,7 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::count(ExecState& execState, JSValue key)
 
     auto idbKey = scriptValueToIDBKey(execState, key);
     if (!idbKey->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'count' on 'IDBIndex': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'count' on 'IDBIndex': The parameter is not a valid key.") };
 
     return doCount(execState, IDBKeyRangeData(idbKey.ptr()));
 }
@@ -232,14 +231,14 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::doCount(ExecState& execState, const IDBKe
     ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID());
 
     if (m_deleted || m_objectStore.isDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'count' on 'IDBIndex': The index or its object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'count' on 'IDBIndex': The index or its object store has been deleted.") };
 
     if (!range.isValid())
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     auto& transaction = m_objectStore.transaction();
     if (!transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'count' on 'IDBIndex': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'count' on 'IDBIndex': The transaction is inactive or finished.") };
 
     return transaction.requestCount(execState, *this, range);
 }
@@ -257,7 +256,7 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::get(ExecState& execState, JSValue key)
 
     auto idbKey = scriptValueToIDBKey(execState, key);
     if (!idbKey->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'get' on 'IDBIndex': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'get' on 'IDBIndex': The parameter is not a valid key.") };
 
     return doGet(execState, IDBKeyRangeData(idbKey.ptr()));
 }
@@ -267,14 +266,14 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::doGet(ExecState& execState, const IDBKeyR
     ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID());
 
     if (m_deleted || m_objectStore.isDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'get' on 'IDBIndex': The index or its object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'get' on 'IDBIndex': The index or its object store has been deleted.") };
 
     if (range.isNull)
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     auto& transaction = m_objectStore.transaction();
     if (!transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'get' on 'IDBIndex': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'get' on 'IDBIndex': The transaction is inactive or finished.") };
 
     return transaction.requestGetValue(execState, *this, range);
 }
@@ -292,7 +291,7 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::getKey(ExecState& execState, JSValue key)
 
     auto idbKey = scriptValueToIDBKey(execState, key);
     if (!idbKey->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'getKey' on 'IDBIndex': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'getKey' on 'IDBIndex': The parameter is not a valid key.") };
 
     return doGetKey(execState, IDBKeyRangeData(idbKey.ptr()));
 }
@@ -302,14 +301,14 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::doGetKey(ExecState& execState, const IDBK
     ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID());
 
     if (m_deleted || m_objectStore.isDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getKey' on 'IDBIndex': The index or its object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'getKey' on 'IDBIndex': The index or its object store has been deleted.") };
 
     if (range.isNull)
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     auto& transaction = m_objectStore.transaction();
     if (!transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getKey' on 'IDBIndex': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'getKey' on 'IDBIndex': The transaction is inactive or finished.") };
 
     return transaction.requestGetKey(execState, *this, range);
 }
@@ -320,10 +319,10 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::getAll(ExecState& execState, RefPtr<IDBKe
     ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID());
 
     if (m_deleted || m_objectStore.isDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getAll' on 'IDBIndex': The index or its object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'getAll' on 'IDBIndex': The index or its object store has been deleted.") };
 
     if (!m_objectStore.transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getAll' on 'IDBIndex': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'getAll' on 'IDBIndex': The transaction is inactive or finished.") };
 
     return m_objectStore.transaction().requestGetAllIndexRecords(execState, *this, range.get(), IndexedDB::GetAllType::Values, count);
 }
@@ -332,7 +331,7 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::getAll(ExecState& execState, JSValue key,
 {
     auto onlyResult = IDBKeyRange::only(execState, key);
     if (onlyResult.hasException())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'getAll' on 'IDBIndex': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'getAll' on 'IDBIndex': The parameter is not a valid key.") };
 
     return getAll(execState, onlyResult.releaseReturnValue(), count);
 }
@@ -343,10 +342,10 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::getAllKeys(ExecState& execState, RefPtr<I
     ASSERT(currentThread() == m_objectStore.transaction().database().originThreadID());
 
     if (m_deleted || m_objectStore.isDeleted())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The index or its object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The index or its object store has been deleted.") };
 
     if (!m_objectStore.transaction().isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The transaction is inactive or finished.") };
 
     return m_objectStore.transaction().requestGetAllIndexRecords(execState, *this, range.get(), IndexedDB::GetAllType::Keys, count);
 }
@@ -355,7 +354,7 @@ ExceptionOr<Ref<IDBRequest>> IDBIndex::getAllKeys(ExecState& execState, JSValue
 {
     auto onlyResult = IDBKeyRange::only(execState, key);
     if (onlyResult.hasException())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBIndex': The parameter is not a valid key.") };
 
     return getAllKeys(execState, onlyResult.releaseReturnValue(), count);
 }
index c6511ac..721d021 100644 (file)
@@ -28,8 +28,8 @@
 
 #if ENABLE(INDEXED_DATABASE)
 
+#include "ExceptionCode.h"
 #include "IDBBindingUtilities.h"
-#include "IDBDatabaseException.h"
 #include "IDBKey.h"
 #include "IDBKeyData.h"
 #include "ScriptExecutionContext.h"
@@ -65,7 +65,7 @@ IDBKeyRange::~IDBKeyRange()
 ExceptionOr<Ref<IDBKeyRange>> IDBKeyRange::only(RefPtr<IDBKey>&& key)
 {
     if (!key || !key->isValid())
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     return create(WTFMove(key));
 }
@@ -79,7 +79,7 @@ ExceptionOr<Ref<IDBKeyRange>> IDBKeyRange::lowerBound(ExecState& state, JSValue
 {
     auto bound = scriptValueToIDBKey(state, boundValue);
     if (!bound->isValid())
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     return create(WTFMove(bound), nullptr, open, true);
 }
@@ -88,7 +88,7 @@ ExceptionOr<Ref<IDBKeyRange>> IDBKeyRange::upperBound(ExecState& state, JSValue
 {
     auto bound = scriptValueToIDBKey(state, boundValue);
     if (!bound->isValid())
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     return create(nullptr, WTFMove(bound), true, open);
 }
@@ -99,11 +99,11 @@ ExceptionOr<Ref<IDBKeyRange>> IDBKeyRange::bound(ExecState& state, JSValue lower
     auto upper = scriptValueToIDBKey(state, upperValue);
 
     if (!lower->isValid() || !upper->isValid())
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
     if (upper->isLessThan(lower.get()))
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
     if (upper->isEqual(lower.get()) && (lowerOpen || upperOpen))
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     return create(WTFMove(lower), WTFMove(upper), lowerOpen, upperOpen);
 }
@@ -117,7 +117,7 @@ ExceptionOr<bool> IDBKeyRange::includes(JSC::ExecState& state, JSC::JSValue keyV
 {
     auto key = scriptValueToIDBKey(state, keyValue);
     if (!key->isValid())
-        return Exception { IDBDatabaseException::DataError, "Failed to execute 'includes' on 'IDBKeyRange': The passed-in value is not a valid IndexedDB key." };
+        return Exception { DataError, "Failed to execute 'includes' on 'IDBKeyRange': The passed-in value is not a valid IndexedDB key." };
 
     if (m_lower) {
         int compare = m_lower->compare(key.get());
index 518eb1b..085bd53 100644 (file)
@@ -34,7 +34,6 @@
 #include "IDBBindingUtilities.h"
 #include "IDBCursor.h"
 #include "IDBDatabase.h"
-#include "IDBDatabaseException.h"
 #include "IDBError.h"
 #include "IDBGetRecordData.h"
 #include "IDBIndex.h"
@@ -105,13 +104,13 @@ ExceptionOr<void> IDBObjectStore::setName(const String& name)
         return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed set property 'name' on 'IDBObjectStore': The object store's transaction is not a version change transaction.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed set property 'name' on 'IDBObjectStore': The object store's transaction is not active.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed set property 'name' on 'IDBObjectStore': The object store's transaction is not active.") };
 
     if (m_info.name() == name)
         return { };
 
     if (m_transaction.database().info().hasObjectStore(name))
-        return Exception { IDBDatabaseException::ConstraintError, makeString("Failed set property 'name' on 'IDBObjectStore': The database already has an object store named '", name, "'.") };
+        return Exception { ConstraintError, makeString("Failed set property 'name' on 'IDBObjectStore': The database already has an object store named '", name, "'.") };
 
     m_transaction.database().renameObjectStore(*this, name);
     m_info.rename(name);
@@ -158,10 +157,10 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::openCursor(ExecState& execState, Re
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'openCursor' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     auto info = IDBCursorInfo::objectStoreCursor(m_transaction, m_info.identifier(), range.get(), direction, IndexedDB::CursorType::KeyAndValue);
     return m_transaction.requestOpenCursor(execState, *this, info);
@@ -171,7 +170,7 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::openCursor(ExecState& execState, JS
 {
     auto onlyResult = IDBKeyRange::only(execState, key);
     if (onlyResult.hasException())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBObjectStore': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'openCursor' on 'IDBObjectStore': The parameter is not a valid key.") };
 
     return openCursor(execState, onlyResult.releaseReturnValue(), direction);
 }
@@ -182,10 +181,10 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::openKeyCursor(ExecState& execState,
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     auto info = IDBCursorInfo::objectStoreCursor(m_transaction, m_info.identifier(), range.get(), direction, IndexedDB::CursorType::KeyOnly);
     return m_transaction.requestOpenCursor(execState, *this, info);
@@ -195,7 +194,7 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::openKeyCursor(ExecState& execState,
 {
     auto onlyResult = IDBKeyRange::only(execState, key);
     if (onlyResult.hasException())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBObjectStore': The parameter is not a valid key or key range.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'openKeyCursor' on 'IDBObjectStore': The parameter is not a valid key or key range.") };
 
     return openKeyCursor(execState, onlyResult.releaseReturnValue(), direction);
 }
@@ -206,14 +205,14 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::get(ExecState& execState, JSValue k
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     auto idbKey = scriptValueToIDBKey(execState, key);
     if (!idbKey->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The parameter is not a valid key.") };
 
     return m_transaction.requestGetRecord(execState, *this, { idbKey.ptr(), IDBGetRecordDataType::KeyAndValue });
 }
@@ -224,14 +223,14 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::get(ExecState& execState, IDBKeyRan
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'get' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError };
+        return Exception { TransactionInactiveError };
 
     IDBKeyRangeData keyRangeData(keyRange);
     if (!keyRangeData.isValid())
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     return m_transaction.requestGetRecord(execState, *this, { keyRangeData, IDBGetRecordDataType::KeyAndValue });
 }
@@ -242,14 +241,14 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::getKey(ExecState& execState, JSValu
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     auto idbKey = scriptValueToIDBKey(execState, key);
     if (!idbKey->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The parameter is not a valid key.") };
 
     return m_transaction.requestGetRecord(execState, *this, { idbKey.ptr(), IDBGetRecordDataType::KeyOnly });
 }
@@ -260,14 +259,14 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::getKey(ExecState& execState, IDBKey
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     IDBKeyRangeData keyRangeData(keyRange);
     if (!keyRangeData.isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The parameter is not a valid key range.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'getKey' on 'IDBObjectStore': The parameter is not a valid key range.") };
 
     return m_transaction.requestGetRecord(execState, *this, { keyRangeData, IDBGetRecordDataType::KeyOnly });
 }
@@ -303,23 +302,23 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::putOrAdd(ExecState& state, JSValue
 
     auto context = scriptExecutionContextFromExecState(&state);
     if (!context)
-        return Exception { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to store record in object store because it does not have a valid script execution context") };
+        return Exception { UnknownError, ASCIILiteral("Unable to store record in object store because it does not have a valid script execution context") };
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to store record in an IDBObjectStore: The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to store record in an IDBObjectStore: The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to store record in an IDBObjectStore: The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to store record in an IDBObjectStore: The transaction is inactive or finished.") };
 
     if (m_transaction.isReadOnly())
-        return Exception { IDBDatabaseException::ReadOnlyError, ASCIILiteral("Failed to store record in an IDBObjectStore: The transaction is read-only.") };
+        return Exception { ReadonlyError, ASCIILiteral("Failed to store record in an IDBObjectStore: The transaction is read-only.") };
 
     auto serializedValue = SerializedScriptValue::create(state, value);
     if (UNLIKELY(scope.exception())) {
         // Clear the DOM exception from the serializer so we can give a more targeted exception.
         scope.clearException();
 
-        return Exception { IDBDatabaseException::DataCloneError, ASCIILiteral("Failed to store record in an IDBObjectStore: An object could not be cloned.") };
+        return Exception { DATA_CLONE_ERR, ASCIILiteral("Failed to store record in an IDBObjectStore: An object could not be cloned.") };
     }
 
     bool privateBrowsingEnabled = false;
@@ -330,27 +329,27 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::putOrAdd(ExecState& state, JSValue
 
     if (serializedValue->hasBlobURLs() && privateBrowsingEnabled) {
         // https://bugs.webkit.org/show_bug.cgi?id=156347 - Support Blobs in private browsing.
-        return Exception { IDBDatabaseException::DataCloneError, ASCIILiteral("Failed to store record in an IDBObjectStore: BlobURLs are not yet supported.") };
+        return Exception { DATA_CLONE_ERR, ASCIILiteral("Failed to store record in an IDBObjectStore: BlobURLs are not yet supported.") };
     }
 
     if (key && !key->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: The parameter is not a valid key.") };
 
     bool usesInlineKeys = !!m_info.keyPath();
     bool usesKeyGenerator = autoIncrement();
     if (usesInlineKeys && inlineKeyCheck == InlineKeyCheck::Perform) {
         if (key)
-            return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: The object store uses in-line keys and the key parameter was provided.") };
+            return Exception { DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: The object store uses in-line keys and the key parameter was provided.") };
 
         RefPtr<IDBKey> keyPathKey = maybeCreateIDBKeyFromScriptValueAndKeyPath(state, value, m_info.keyPath().value());
         if (keyPathKey && !keyPathKey->isValid())
-            return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: Evaluating the object store's key path yielded a value that is not a valid key.") };
+            return Exception { DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: Evaluating the object store's key path yielded a value that is not a valid key.") };
 
         if (!keyPathKey) {
             if (!usesKeyGenerator)
-                return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: Evaluating the object store's key path did not yield a value.") };
+                return Exception { DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: Evaluating the object store's key path did not yield a value.") };
             if (!canInjectIDBKeyIntoScriptValue(state, value, m_info.keyPath().value()))
-                return Exception { IDBDatabaseException::DataError };
+                return Exception { DataError };
         }
 
         if (keyPathKey) {
@@ -358,7 +357,7 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::putOrAdd(ExecState& state, JSValue
             key = keyPathKey;
         }
     } else if (!usesKeyGenerator && !key)
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: The object store uses out-of-line keys and has no key generator and the key parameter was not provided.") };
+        return Exception { DataError, ASCIILiteral("Failed to store record in an IDBObjectStore: The object store uses out-of-line keys and has no key generator and the key parameter was not provided.") };
 
     return m_transaction.requestPutOrAdd(state, *this, key.get(), *serializedValue, overwriteMode);
 }
@@ -379,17 +378,17 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::doDelete(ExecState& execState, IDBK
     // Additionally, Chrome and Edge agree with the test, as does Legacy IDB in WebKit.
     // Until this is sorted out, we'll agree with the test and the majority share browsers.
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     if (m_transaction.isReadOnly())
-        return Exception { IDBDatabaseException::ReadOnlyError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The transaction is read-only.") };
+        return Exception { ReadonlyError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The transaction is read-only.") };
 
     IDBKeyRangeData keyRangeData(keyRange);
     if (!keyRangeData.isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The parameter is not a valid key range.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The parameter is not a valid key range.") };
 
     return m_transaction.requestDeleteRecord(execState, *this, keyRangeData);
 }
@@ -398,7 +397,7 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::deleteFunction(ExecState& execState
 {
     Ref<IDBKey> idbKey = scriptValueToIDBKey(execState, key);
     if (!idbKey->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The parameter is not a valid key.") };
     return doDelete(execState, IDBKeyRange::create(WTFMove(idbKey)).ptr());
 }
 
@@ -413,13 +412,13 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::clear(ExecState& execState)
     // Additionally, Chrome and Edge agree with the test, as does Legacy IDB in WebKit.
     // Until this is sorted out, we'll agree with the test and the majority share browsers.
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'clear' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'clear' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'clear' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'clear' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     if (m_transaction.isReadOnly())
-        return Exception { IDBDatabaseException::ReadOnlyError, ASCIILiteral("Failed to execute 'clear' on 'IDBObjectStore': The transaction is read-only.") };
+        return Exception { ReadonlyError, ASCIILiteral("Failed to execute 'clear' on 'IDBObjectStore': The transaction is read-only.") };
 
     return m_transaction.requestClearObjectStore(execState, *this);
 }
@@ -430,25 +429,25 @@ ExceptionOr<Ref<IDBIndex>> IDBObjectStore::createIndex(ExecState&, const String&
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (!m_transaction.isVersionChange())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The database is not running a version change transaction.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The database is not running a version change transaction.") };
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The transaction is inactive.")};
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The transaction is inactive.")};
 
     if (m_info.hasIndex(name))
-        return Exception { IDBDatabaseException::ConstraintError, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': An index with the specified name already exists.") };
+        return Exception { ConstraintError, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': An index with the specified name already exists.") };
 
     if (!isIDBKeyPathValid(keyPath))
-        return Exception { IDBDatabaseException::SyntaxError, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The keyPath argument contains an invalid key path.") };
+        return Exception { SYNTAX_ERR, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The keyPath argument contains an invalid key path.") };
 
     if (name.isNull())
         return Exception { TypeError };
 
     if (parameters.multiEntry && WTF::holds_alternative<Vector<String>>(keyPath))
-        return Exception { IDBDatabaseException::InvalidAccessError, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The keyPath argument was an array and the multiEntry option is true.") };
+        return Exception { INVALID_ACCESS_ERR, ASCIILiteral("Failed to execute 'createIndex' on 'IDBObjectStore': The keyPath argument was an array and the multiEntry option is true.") };
 
     // Install the new Index into the ObjectStore's info.
     IDBIndexInfo info = m_info.createNewIndex(name, WTFMove(keyPath), parameters.unique, parameters.multiEntry);
@@ -471,13 +470,13 @@ ExceptionOr<Ref<IDBIndex>> IDBObjectStore::index(const String& indexName)
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (!scriptExecutionContext())
-        return Exception { IDBDatabaseException::InvalidStateError }; // FIXME: Is this code tested? Is iteven reachable?
+        return Exception { INVALID_STATE_ERR }; // FIXME: Is this code tested? Is iteven reachable?
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'index' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'index' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (m_transaction.isFinishedOrFinishing())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'index' on 'IDBObjectStore': The transaction is finished.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'index' on 'IDBObjectStore': The transaction is finished.") };
 
     Locker<Lock> locker(m_referencedIndexLock);
     auto iterator = m_referencedIndexes.find(indexName);
@@ -486,7 +485,7 @@ ExceptionOr<Ref<IDBIndex>> IDBObjectStore::index(const String& indexName)
 
     auto* info = m_info.infoForExistingIndex(indexName);
     if (!info)
-        return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'index' on 'IDBObjectStore': The specified index was not found.") };
+        return Exception { NOT_FOUND_ERR, ASCIILiteral("Failed to execute 'index' on 'IDBObjectStore': The specified index was not found.") };
 
     auto index = std::make_unique<IDBIndex>(*scriptExecutionContext(), *info, *this);
 
@@ -503,16 +502,16 @@ ExceptionOr<void> IDBObjectStore::deleteIndex(const String& name)
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'deleteIndex' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'deleteIndex' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isVersionChange())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'deleteIndex' on 'IDBObjectStore': The database is not running a version change transaction.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'deleteIndex' on 'IDBObjectStore': The database is not running a version change transaction.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError,  ASCIILiteral("Failed to execute 'deleteIndex' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError,  ASCIILiteral("Failed to execute 'deleteIndex' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     if (!m_info.hasIndex(name))
-        return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'deleteIndex' on 'IDBObjectStore': The specified index was not found.") };
+        return Exception { NOT_FOUND_ERR, ASCIILiteral("Failed to execute 'deleteIndex' on 'IDBObjectStore': The specified index was not found.") };
 
     auto* info = m_info.infoForExistingIndex(name);
     ASSERT(info);
@@ -539,7 +538,7 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::count(ExecState& execState, JSValue
 
     Ref<IDBKey> idbKey = scriptValueToIDBKey(execState, key);
     if (!idbKey->isValid())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'count' on 'IDBObjectStore': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'count' on 'IDBObjectStore': The parameter is not a valid key.") };
 
     return doCount(execState, IDBKeyRangeData(idbKey.ptr()));
 }
@@ -561,13 +560,13 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::doCount(ExecState& execState, const
     // Additionally, Chrome and Edge agree with the test, as does Legacy IDB in WebKit.
     // Until this is sorted out, we'll agree with the test and the majority share browsers.
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'count' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'count' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'count' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'count' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     if (!range.isValid())
-        return Exception { IDBDatabaseException::DataError };
+        return Exception { DataError };
 
     return m_transaction.requestCount(execState, *this, range);
 }
@@ -578,10 +577,10 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::getAll(ExecState& execState, RefPtr
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getAll' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'getAll' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getAll' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'getAll' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     return m_transaction.requestGetAllObjectStoreRecords(execState, *this, range.get(), IndexedDB::GetAllType::Values, count);
 }
@@ -590,7 +589,7 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::getAll(ExecState& execState, JSValu
 {
     auto onlyResult = IDBKeyRange::only(execState, key);
     if (onlyResult.hasException())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'getAll' on 'IDBObjectStore': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'getAll' on 'IDBObjectStore': The parameter is not a valid key.") };
 
     return getAll(execState, onlyResult.releaseReturnValue(), count);
 }
@@ -601,10 +600,10 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::getAllKeys(ExecState& execState, Re
     ASSERT(currentThread() == m_transaction.database().originThreadID());
 
     if (m_deleted)
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBObjectStore': The object store has been deleted.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBObjectStore': The object store has been deleted.") };
 
     if (!m_transaction.isActive())
-        return Exception { IDBDatabaseException::TransactionInactiveError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBObjectStore': The transaction is inactive or finished.") };
+        return Exception { TransactionInactiveError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBObjectStore': The transaction is inactive or finished.") };
 
     return m_transaction.requestGetAllObjectStoreRecords(execState, *this, range.get(), IndexedDB::GetAllType::Keys, count);
 }
@@ -613,7 +612,7 @@ ExceptionOr<Ref<IDBRequest>> IDBObjectStore::getAllKeys(ExecState& execState, JS
 {
     auto onlyResult = IDBKeyRange::only(execState, key);
     if (onlyResult.hasException())
-        return Exception { IDBDatabaseException::DataError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBObjectStore': The parameter is not a valid key.") };
+        return Exception { DataError, ASCIILiteral("Failed to execute 'getAllKeys' on 'IDBObjectStore': The parameter is not a valid key.") };
 
     return getAllKeys(execState, onlyResult.releaseReturnValue(), count);
 }
index 6b79850..874bc2c 100644 (file)
@@ -104,7 +104,7 @@ void IDBOpenDBRequest::fireErrorAfterVersionChangeCompletion()
     ASSERT(currentThread() == originThreadID());
     ASSERT(hasPendingActivity());
 
-    IDBError idbError(IDBDatabaseException::AbortError);
+    IDBError idbError(ABORT_ERR);
     m_domError = DOMError::create(idbError.name(), idbError.message());
     setResultToUndefined();
 
index 1f96346..7f5ff13 100644 (file)
@@ -36,7 +36,6 @@
 #include "IDBConnectionProxy.h"
 #include "IDBCursor.h"
 #include "IDBDatabase.h"
-#include "IDBDatabaseException.h"
 #include "IDBEventDispatcher.h"
 #include "IDBIndex.h"
 #include "IDBKeyData.h"
@@ -157,7 +156,7 @@ IDBRequest::~IDBRequest()
 ExceptionOr<std::optional<IDBRequest::Result>> IDBRequest::result() const
 {
     if (!isDone())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to read the 'result' property from 'IDBRequest': The request has not finished.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to read the 'result' property from 'IDBRequest': The request has not finished.") };
 
     return std::optional<IDBRequest::Result> { m_result };
 }
@@ -167,7 +166,7 @@ ExceptionOr<DOMError*> IDBRequest::error() const
     ASSERT(currentThread() == originThreadID());
 
     if (!isDone())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to read the 'error' property from 'IDBRequest': The request has not finished.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to read the 'error' property from 'IDBRequest': The request has not finished.") };
 
     return m_domError.get();
 }
@@ -354,8 +353,8 @@ void IDBRequest::uncaughtExceptionInEventHandler()
 
     ASSERT(currentThread() == originThreadID());
 
-    if (m_transaction && m_idbError.code() != IDBDatabaseException::AbortError)
-        m_transaction->abortDueToFailedRequest(DOMError::create(IDBDatabaseException::getErrorName(IDBDatabaseException::AbortError), ASCIILiteral("IDBTransaction will abort due to uncaught exception in an event handler")));
+    if (m_transaction && m_idbError.code() != ABORT_ERR)
+        m_transaction->abortDueToFailedRequest(DOMError::create("AbortError", ASCIILiteral("IDBTransaction will abort due to uncaught exception in an event handler")));
 }
 
 void IDBRequest::setResult(const IDBKeyData& keyData)
index 8b6488a..869a742 100644 (file)
@@ -36,7 +36,6 @@
 #include "EventQueue.h"
 #include "IDBCursorWithValue.h"
 #include "IDBDatabase.h"
-#include "IDBDatabaseException.h"
 #include "IDBError.h"
 #include "IDBEventDispatcher.h"
 #include "IDBGetRecordData.h"
@@ -147,10 +146,10 @@ ExceptionOr<Ref<IDBObjectStore>> IDBTransaction::objectStore(const String& objec
     ASSERT(currentThread() == m_database->originThreadID());
 
     if (!scriptExecutionContext())
-        return Exception { IDBDatabaseException::InvalidStateError };
+        return Exception { INVALID_STATE_ERR };
 
     if (isFinishedOrFinishing())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The transaction finished.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The transaction finished.") };
 
     Locker<Lock> locker(m_referencedObjectStoreLock);
 
@@ -168,11 +167,11 @@ ExceptionOr<Ref<IDBObjectStore>> IDBTransaction::objectStore(const String& objec
 
     auto* info = m_database->info().infoForExistingObjectStore(objectStoreName);
     if (!info)
-        return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The specified object store was not found.") };
+        return Exception { NOT_FOUND_ERR, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The specified object store was not found.") };
 
     // Version change transactions are scoped to every object store in the database.
     if (!info || (!found && !isVersionChange()))
-        return Exception { IDBDatabaseException::NotFoundError, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The specified object store was not found.") };
+        return Exception { NOT_FOUND_ERR, ASCIILiteral("Failed to execute 'objectStore' on 'IDBTransaction': The specified object store was not found.") };
 
     auto objectStore = std::make_unique<IDBObjectStore>(*scriptExecutionContext(), *info, *this);
     auto* rawObjectStore = objectStore.get();
@@ -209,7 +208,7 @@ ExceptionOr<void> IDBTransaction::abort()
     ASSERT(currentThread() == m_database->originThreadID());
 
     if (isFinishedOrFinishing())
-        return Exception { IDBDatabaseException::InvalidStateError, ASCIILiteral("Failed to execute 'abort' on 'IDBTransaction': The transaction is inactive or finished.") };
+        return Exception { INVALID_STATE_ERR, ASCIILiteral("Failed to execute 'abort' on 'IDBTransaction': The transaction is inactive or finished.") };
 
     internalAbort();
 
@@ -295,7 +294,7 @@ void IDBTransaction::abortOnServerAndCancelRequests(IDBClient::TransactionOperat
 
     m_currentlyCompletingRequest = nullptr;
     
-    IDBError error(IDBDatabaseException::AbortError);
+    IDBError error(ABORT_ERR);
 
     abortInProgressOperations(error);
 
@@ -760,7 +759,7 @@ void IDBTransaction::didCreateIndexOnServer(const IDBResultData& resultData)
         return;
 
     // Otherwise, failure to create an index forced abortion of the transaction.
-    abortDueToFailedRequest(DOMError::create(IDBDatabaseException::getErrorName(resultData.error().code()), resultData.error().message()));
+    abortDueToFailedRequest(DOMError::create(resultData.error().name(), resultData.error().message()));
 }
 
 void IDBTransaction::renameIndex(IDBIndex& index, const String& newName)
@@ -1217,7 +1216,7 @@ void IDBTransaction::putOrAddOnServer(IDBClient::TransactionOperation& operation
             // If the IDBValue doesn't have any data, then something went wrong writing the blobs to disk.
             // In that case, we cannot successfully store this record, so we callback with an error.
             RefPtr<IDBClient::TransactionOperation> protectedOperation(&operation);
-            auto result = IDBResultData::error(operation.identifier(), { IDBDatabaseException::UnknownError, ASCIILiteral("Error preparing Blob/File data to be stored in object store") });
+            auto result = IDBResultData::error(operation.identifier(), { UnknownError, ASCIILiteral("Error preparing Blob/File data to be stored in object store") });
             scriptExecutionContext()->postTask([protectedOperation = WTFMove(protectedOperation), result = WTFMove(result)](ScriptExecutionContext&) {
                 protectedOperation->doComplete(result);
             });
@@ -1239,7 +1238,7 @@ void IDBTransaction::putOrAddOnServer(IDBClient::TransactionOperation& operation
 
         // If the IDBValue doesn't have any data, then something went wrong writing the blobs to disk.
         // In that case, we cannot successfully store this record, so we callback with an error.
-        auto result = IDBResultData::error(protectedOperation->identifier(), { IDBDatabaseException::UnknownError, ASCIILiteral("Error preparing Blob/File data to be stored in object store") });
+        auto result = IDBResultData::error(protectedOperation->identifier(), { UnknownError, ASCIILiteral("Error preparing Blob/File data to be stored in object store") });
         callOnMainThread([protectedThis = WTFMove(protectedThis), protectedOperation = WTFMove(protectedOperation), result = WTFMove(result)]() mutable {
             protectedOperation->doComplete(result);
         });
index 3990c05..d7cdb77 100644 (file)
@@ -89,7 +89,7 @@ IDBError IndexValueStore::addRecord(const IDBKeyData& indexKey, const IDBKeyData
     auto result = m_records.add(indexKey, nullptr);
 
     if (!result.isNewEntry && m_unique)
-        return IDBError(IDBDatabaseException::ConstraintError);
+        return IDBError(ConstraintError);
 
     if (result.isNewEntry)
         result.iterator->value = std::make_unique<IndexValueEntry>(m_unique);
index e633089..7e037e4 100644 (file)
@@ -82,7 +82,7 @@ IDBError MemoryIDBBackingStore::beginTransaction(const IDBTransactionInfo& info)
     LOG(IndexedDB, "MemoryIDBBackingStore::beginTransaction");
 
     if (m_transactions.contains(info.identifier()))
-        return { IDBDatabaseException::InvalidStateError, "Backing store asked to create transaction it already has a record of" };
+        return { INVALID_STATE_ERR, "Backing store asked to create transaction it already has a record of" };
 
     auto transaction = MemoryBackingStoreTransaction::create(*this, info);
 
@@ -108,7 +108,7 @@ IDBError MemoryIDBBackingStore::abortTransaction(const IDBResourceIdentifier& tr
 
     auto transaction = m_transactions.take(transactionIdentifier);
     if (!transaction)
-        return { IDBDatabaseException::InvalidStateError, "Backing store asked to abort transaction it didn't have record of" };
+        return { INVALID_STATE_ERR, "Backing store asked to abort transaction it didn't have record of" };
 
     transaction->abort();
 
@@ -121,7 +121,7 @@ IDBError MemoryIDBBackingStore::commitTransaction(const IDBResourceIdentifier& t
 
     auto transaction = m_transactions.take(transactionIdentifier);
     if (!transaction)
-        return { IDBDatabaseException::InvalidStateError, "Backing store asked to commit transaction it didn't have record of" };
+        return { INVALID_STATE_ERR, "Backing store asked to commit transaction it didn't have record of" };
 
     transaction->commit();
 
@@ -134,7 +134,7 @@ IDBError MemoryIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t
 
     ASSERT(m_databaseInfo);
     if (m_databaseInfo->hasObjectStore(info.name()))
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     ASSERT(!m_objectStoresByIdentifier.contains(info.identifier()));
     auto objectStore = MemoryObjectStore::create(info);
@@ -157,7 +157,7 @@ IDBError MemoryIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
 
     ASSERT(m_databaseInfo);
     if (!m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier))
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     auto transaction = m_transactions.get(transactionIdentifier);
     ASSERT(transaction);
@@ -166,7 +166,7 @@ IDBError MemoryIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
     auto objectStore = takeObjectStoreByIdentifier(objectStoreIdentifier);
     ASSERT(objectStore);
     if (!objectStore)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     m_databaseInfo->deleteObjectStore(objectStore->info().name());
     transaction->objectStoreDeleted(*objectStore);
@@ -180,7 +180,7 @@ IDBError MemoryIDBBackingStore::renameObjectStore(const IDBResourceIdentifier& t
 
     ASSERT(m_databaseInfo);
     if (!m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier))
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     auto transaction = m_transactions.get(transactionIdentifier);
     ASSERT(transaction);
@@ -189,7 +189,7 @@ IDBError MemoryIDBBackingStore::renameObjectStore(const IDBResourceIdentifier& t
     auto objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
     ASSERT(objectStore);
     if (!objectStore)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     String oldName = objectStore->info().name();
     objectStore->rename(newName);
@@ -214,7 +214,7 @@ IDBError MemoryIDBBackingStore::clearObjectStore(const IDBResourceIdentifier& tr
 
     auto objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
     if (!objectStore)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     objectStore->clear();
 
@@ -231,7 +231,7 @@ IDBError MemoryIDBBackingStore::createIndex(const IDBResourceIdentifier& transac
 
     auto* objectStore = m_objectStoresByIdentifier.get(info.objectStoreIdentifier());
     if (!objectStore)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     return objectStore->createIndex(*rawTransaction, info);
 }
@@ -246,7 +246,7 @@ IDBError MemoryIDBBackingStore::deleteIndex(const IDBResourceIdentifier& transac
 
     auto* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
     if (!objectStore)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     return objectStore->deleteIndex(*rawTransaction, indexIdentifier);
 }
@@ -258,11 +258,11 @@ IDBError MemoryIDBBackingStore::renameIndex(const IDBResourceIdentifier& transac
     ASSERT(m_databaseInfo);
     auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
     if (!objectStoreInfo)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     auto* indexInfo = objectStoreInfo->infoForExistingIndex(indexIdentifier);
     if (!indexInfo)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     auto transaction = m_transactions.get(transactionIdentifier);
     ASSERT(transaction);
@@ -271,12 +271,12 @@ IDBError MemoryIDBBackingStore::renameIndex(const IDBResourceIdentifier& transac
     auto objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
     ASSERT(objectStore);
     if (!objectStore)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     auto* index = objectStore->indexForIdentifier(indexIdentifier);
     ASSERT(index);
     if (!index)
-        return { IDBDatabaseException::ConstraintError };
+        return { ConstraintError };
 
     String oldName = index->info().name();
     objectStore->renameIndex(*index, newName);
@@ -324,11 +324,11 @@ IDBError MemoryIDBBackingStore::deleteRange(const IDBResourceIdentifier& transac
     ASSERT(objectStoreIdentifier);
 
     if (!m_transactions.contains(transactionIdentifier))
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to delete from") };
+        return { UnknownError, ASCIILiteral("No backing store transaction found to delete from") };
 
     MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
     if (!objectStore)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
+        return { UnknownError, ASCIILiteral("No backing store object store found") };
 
     objectStore->deleteRange(range);
     return { };
@@ -342,11 +342,11 @@ IDBError MemoryIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
 
     auto transaction = m_transactions.get(transactionIdentifier);
     if (!transaction)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to put record") };
+        return { UnknownError, ASCIILiteral("No backing store transaction found to put record") };
 
     MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreInfo.identifier());
     if (!objectStore)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found to put record") };
+        return { UnknownError, ASCIILiteral("No backing store object store found to put record") };
 
     return objectStore->addRecord(*transaction, keyData, value);
 }
@@ -358,11 +358,11 @@ IDBError MemoryIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
     ASSERT(objectStoreIdentifier);
 
     if (!m_transactions.contains(transactionIdentifier))
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get record") };
+        return { UnknownError, ASCIILiteral("No backing store transaction found to get record") };
 
     MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
     if (!objectStore)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
+        return { UnknownError, ASCIILiteral("No backing store object store found") };
 
     switch (type) {
     case IDBGetRecordDataType::KeyAndValue:
@@ -383,16 +383,16 @@ IDBError MemoryIDBBackingStore::getAllRecords(const IDBResourceIdentifier& trans
     ASSERT(getAllRecordsData.objectStoreIdentifier);
 
     if (!m_transactions.contains(transactionIdentifier))
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get all records") };
+        return { UnknownError, ASCIILiteral("No backing store transaction found to get all records") };
 
     auto* objectStore = m_objectStoresByIdentifier.get(getAllRecordsData.objectStoreIdentifier);
     if (!objectStore)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
+        return { UnknownError, ASCIILiteral("No backing store object store found") };
 
     if (getAllRecordsData.indexIdentifier) {
         auto* index = objectStore->indexForIdentifier(getAllRecordsData.indexIdentifier);
         if (!index)
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store index found") };
+            return { UnknownError, ASCIILiteral("No backing store index found") };
 
         index->getAllRecords(getAllRecordsData.keyRangeData, getAllRecordsData.count, getAllRecordsData.getAllType, result);
     } else
@@ -408,11 +408,11 @@ IDBError MemoryIDBBackingStore::getIndexRecord(const IDBResourceIdentifier& tran
     ASSERT(objectStoreIdentifier);
 
     if (!m_transactions.contains(transactionIdentifier))
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get record") };
+        return { UnknownError, ASCIILiteral("No backing store transaction found to get record") };
 
     MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
     if (!objectStore)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
+        return { UnknownError, ASCIILiteral("No backing store object store found") };
 
     outValue = objectStore->indexValueForKeyRange(indexIdentifier, recordType, range);
     return { };
@@ -425,11 +425,11 @@ IDBError MemoryIDBBackingStore::getCount(const IDBResourceIdentifier& transactio
     ASSERT(objectStoreIdentifier);
 
     if (!m_transactions.contains(transactionIdentifier))
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found to get count") };
+        return { UnknownError, ASCIILiteral("No backing store transaction found to get count") };
 
     MemoryObjectStore* objectStore = m_objectStoresByIdentifier.get(objectStoreIdentifier);
     if (!objectStore)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
+        return { UnknownError, ASCIILiteral("No backing store object store found") };
 
     outCount = objectStore->countForKeyRange(indexIdentifier, range);
 
@@ -448,7 +448,7 @@ IDBError MemoryIDBBackingStore::generateKeyNumber(const IDBResourceIdentifier& t
 
     keyNumber = objectStore->currentKeyGeneratorValue();
     if (keyNumber > maxGeneratedKeyValue)
-        return { IDBDatabaseException::ConstraintError, "Cannot generate new key value over 2^53 for object store operation" };
+        return { ConstraintError, "Cannot generate new key value over 2^53 for object store operation" };
 
     objectStore->setKeyGeneratorValue(keyNumber + 1);
 
@@ -501,17 +501,17 @@ IDBError MemoryIDBBackingStore::openCursor(const IDBResourceIdentifier& transact
     ASSERT(!MemoryCursor::cursorForIdentifier(info.identifier()));
 
     if (!m_transactions.contains(transactionIdentifier))
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found in which to open a cursor") };
+        return { UnknownError, ASCIILiteral("No backing store transaction found in which to open a cursor") };
 
     switch (info.cursorSource()) {
     case IndexedDB::CursorSource::ObjectStore: {
         auto* objectStore = m_objectStoresByIdentifier.get(info.sourceIdentifier());
         if (!objectStore)
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
+            return { UnknownError, ASCIILiteral("No backing store object store found") };
 
         MemoryCursor* cursor = objectStore->maybeOpenCursor(info);
         if (!cursor)
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not create object store cursor in backing store") };
+            return { UnknownError, ASCIILiteral("Could not create object store cursor in backing store") };
 
         cursor->currentData(outData);
         break;
@@ -519,15 +519,15 @@ IDBError MemoryIDBBackingStore::openCursor(const IDBResourceIdentifier& transact
     case IndexedDB::CursorSource::Index:
         auto* objectStore = m_objectStoresByIdentifier.get(info.objectStoreIdentifier());
         if (!objectStore)
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store object store found") };
+            return { UnknownError, ASCIILiteral("No backing store object store found") };
 
         auto* index = objectStore->indexForIdentifier(info.sourceIdentifier());
         if (!index)
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store index found") };
+            return { UnknownError, ASCIILiteral("No backing store index found") };
 
         MemoryCursor* cursor = index->maybeOpenCursor(info);
         if (!cursor)
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not create index cursor in backing store") };
+            return { UnknownError, ASCIILiteral("Could not create index cursor in backing store") };
 
         cursor->currentData(outData);
         break;
@@ -541,11 +541,11 @@ IDBError MemoryIDBBackingStore::iterateCursor(const IDBResourceIdentifier& trans
     LOG(IndexedDB, "MemoryIDBBackingStore::iterateCursor");
 
     if (!m_transactions.contains(transactionIdentifier))
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store transaction found in which to iterate cursor") };
+        return { UnknownError, ASCIILiteral("No backing store transaction found in which to iterate cursor") };
 
     auto* cursor = MemoryCursor::cursorForIdentifier(cursorIdentifier);
     if (!cursor)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No backing store cursor found in which to iterate cursor") };
+        return { UnknownError, ASCIILiteral("No backing store cursor found in which to iterate cursor") };
 
     cursor->iterate(data.keyData, data.primaryKeyData, data.count, outData);
 
index e92d268..fda251b 100644 (file)
@@ -218,7 +218,7 @@ IDBError MemoryIndex::putIndexKey(const IDBKeyData& valueKey, const IndexKey& in
     if (m_info.unique()) {
         for (auto& key : keys) {
             if (m_records->contains(key))
-                return IDBError(IDBDatabaseException::ConstraintError);
+                return IDBError(ConstraintError);
         }
     }
 
index 1ebd588..8130e46 100644 (file)
@@ -29,7 +29,6 @@
 #if ENABLE(INDEXED_DATABASE)
 
 #include "IDBBindingUtilities.h"
-#include "IDBDatabaseException.h"
 #include "IDBError.h"
 #include "IDBGetAllResult.h"
 #include "IDBKeyRangeData.h"
@@ -89,7 +88,7 @@ IDBError MemoryObjectStore::createIndex(MemoryBackingStoreTransaction& transacti
     LOG(IndexedDB, "MemoryObjectStore::createIndex");
 
     if (!m_writeTransaction || !m_writeTransaction->isVersionChange() || m_writeTransaction != &transaction)
-        return IDBError(IDBDatabaseException::ConstraintError);
+        return IDBError(ConstraintError);
 
     ASSERT(!m_indexesByIdentifier.contains(info.identifier()));
     auto index = MemoryIndex::create(info, *this);
@@ -144,12 +143,12 @@ IDBError MemoryObjectStore::deleteIndex(MemoryBackingStoreTransaction& transacti
     LOG(IndexedDB, "MemoryObjectStore::deleteIndex");
 
     if (!m_writeTransaction || !m_writeTransaction->isVersionChange() || m_writeTransaction != &transaction)
-        return IDBError(IDBDatabaseException::ConstraintError);
+        return IDBError(ConstraintError);
     
     auto index = takeIndexByIdentifier(indexIdentifier);
     ASSERT(index);
     if (!index)
-        return IDBError(IDBDatabaseException::ConstraintError);
+        return IDBError(ConstraintError);
 
     m_info.deleteIndex(indexIdentifier);
     transaction.indexDeleted(*index);
index ddabad4..6094cfc 100644 (file)
@@ -30,7 +30,6 @@
 
 #include "FileSystem.h"
 #include "IDBBindingUtilities.h"
-#include "IDBDatabaseException.h"
 #include "IDBGetAllRecordsData.h"
 #include "IDBGetAllResult.h"
 #include "IDBGetRecordData.h"
@@ -794,7 +793,7 @@ IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info
     }
 
     if (!m_sqliteDB)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to open database file on disk") };
+        return { UnknownError, ASCIILiteral("Unable to open database file on disk") };
 
     m_sqliteDB->setCollationFunction("IDBKEY", [](int aLength, const void* a, int bLength, const void* b) {
         return idbKeyCollate(aLength, a, bLength, b);
@@ -803,25 +802,25 @@ IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info
     if (!ensureValidRecordsTable()) {
         LOG_ERROR("Error creating or migrating Records table in database");
         closeSQLiteDB();
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error creating or migrating Records table in database") };
+        return { UnknownError, ASCIILiteral("Error creating or migrating Records table in database") };
     }
 
     if (!ensureValidIndexRecordsTable()) {
         LOG_ERROR("Error creating or migrating Index Records table in database");
         closeSQLiteDB();
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error creating or migrating Index Records table in database") };
+        return { UnknownError, ASCIILiteral("Error creating or migrating Index Records table in database") };
     }
 
     if (!ensureValidIndexRecordsIndex()) {
         LOG_ERROR("Error creating or migrating Index Records index in database");
         closeSQLiteDB();
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error creating or migrating Index Records index in database") };
+        return { UnknownError, ASCIILiteral("Error creating or migrating Index Records index in database") };
     }
 
     if (!ensureValidBlobTables()) {
         LOG_ERROR("Error creating or confirming Blob Records tables in database");
         closeSQLiteDB();
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error creating or confirming Blob Records tables in database") };
+        return { UnknownError, ASCIILiteral("Error creating or confirming Blob Records tables in database") };
     }
 
     auto databaseInfo = extractExistingDatabaseInfo();
@@ -831,7 +830,7 @@ IDBError SQLiteIDBBackingStore::getOrEstablishDatabaseInfo(IDBDatabaseInfo& info
     if (!databaseInfo) {
         LOG_ERROR("Unable to establish IDB database at path '%s'", dbFilename.utf8().data());
         closeSQLiteDB();
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to establish IDB database file") };
+        return { UnknownError, ASCIILiteral("Unable to establish IDB database file") };
     }
 
     m_databaseInfo = WTFMove(databaseInfo);
@@ -850,7 +849,7 @@ IDBError SQLiteIDBBackingStore::beginTransaction(const IDBTransactionInfo& info)
     auto addResult = m_transactions.add(info.identifier(), nullptr);
     if (!addResult.isNewEntry) {
         LOG_ERROR("Attempt to establish transaction identifier that already exists");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to establish transaction identifier that already exists") };
+        return { UnknownError, ASCIILiteral("Attempt to establish transaction identifier that already exists") };
     }
 
     addResult.iterator->value = std::make_unique<SQLiteIDBTransaction>(*this, info);
@@ -863,7 +862,7 @@ IDBError SQLiteIDBBackingStore::beginTransaction(const IDBTransactionInfo& info)
         if (sql.prepare() != SQLITE_OK
             || sql.bindText(1, String::number(info.newVersion())) != SQLITE_OK
             || sql.step() != SQLITE_DONE)
-            error = { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to store new database version in database") };
+            error = { UnknownError, ASCIILiteral("Failed to store new database version in database") };
     }
 
     return error;
@@ -879,7 +878,7 @@ IDBError SQLiteIDBBackingStore::abortTransaction(const IDBResourceIdentifier& id
     auto transaction = m_transactions.take(identifier);
     if (!transaction) {
         LOG_ERROR("Attempt to commit a transaction that hasn't been established");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to abort a transaction that hasn't been established") };
+        return { UnknownError, ASCIILiteral("Attempt to abort a transaction that hasn't been established") };
     }
 
     if (transaction->mode() == IDBTransactionMode::Versionchange && m_originalDatabaseInfoBeforeVersionChange)
@@ -898,7 +897,7 @@ IDBError SQLiteIDBBackingStore::commitTransaction(const IDBResourceIdentifier& i
     auto transaction = m_transactions.take(identifier);
     if (!transaction) {
         LOG_ERROR("Attempt to commit a transaction that hasn't been established");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to commit a transaction that hasn't been established") };
+        return { UnknownError, ASCIILiteral("Attempt to commit a transaction that hasn't been established") };
     }
 
     auto error = transaction->commit();
@@ -923,17 +922,17 @@ IDBError SQLiteIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to create an object store without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to create an object store without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to create an object store without an in-progress transaction") };
     }
     if (transaction->mode() != IDBTransactionMode::Versionchange) {
         LOG_ERROR("Attempt to create an object store in a non-version-change transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to create an object store in a non-version-change transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to create an object store in a non-version-change transaction") };
     }
 
     RefPtr<SharedBuffer> keyPathBlob = serializeIDBKeyPath(info.keyPath());
     if (!keyPathBlob) {
         LOG_ERROR("Unable to serialize IDBKeyPath to save in database for new object store");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize IDBKeyPath to save in database for new object store") };
+        return { UnknownError, ASCIILiteral("Unable to serialize IDBKeyPath to save in database for new object store") };
     }
 
     {
@@ -946,7 +945,7 @@ IDBError SQLiteIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t
             || sql->bindInt64(5, info.maxIndexID()) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not add object store '%s' to ObjectStoreInfo table (%i) - %s", info.name().utf8().data(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not create object store") };
+            return { UnknownError, ASCIILiteral("Could not create object store") };
         }
     }
 
@@ -956,7 +955,7 @@ IDBError SQLiteIDBBackingStore::createObjectStore(const IDBResourceIdentifier& t
             || sql->bindInt64(1, info.identifier()) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not seed initial key generator value for ObjectStoreInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not seed initial key generator value for object store") };
+            return { UnknownError, ASCIILiteral("Could not seed initial key generator value for object store") };
         }
     }
 
@@ -975,11 +974,11 @@ IDBError SQLiteIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to delete an object store without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete an object store without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to delete an object store without an in-progress transaction") };
     }
     if (transaction->mode() != IDBTransactionMode::Versionchange) {
         LOG_ERROR("Attempt to delete an object store in a non-version-change transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete an object store in a non-version-change transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to delete an object store in a non-version-change transaction") };
     }
 
     // Delete the ObjectStore record
@@ -989,7 +988,7 @@ IDBError SQLiteIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
             || sql->bindInt64(1, objectStoreIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete object store id %" PRIi64 " from ObjectStoreInfo table (%i) - %s", objectStoreIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not delete object store") };
+            return { UnknownError, ASCIILiteral("Could not delete object store") };
         }
     }
 
@@ -1000,7 +999,7 @@ IDBError SQLiteIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
             || sql->bindInt64(1, objectStoreIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete object store from KeyGenerators table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not delete key generator for deleted object store") };
+            return { UnknownError, ASCIILiteral("Could not delete key generator for deleted object store") };
         }
     }
 
@@ -1011,7 +1010,7 @@ IDBError SQLiteIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
             || sql->bindInt64(1, objectStoreIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete records for object store %" PRIi64 " (%i) - %s", objectStoreIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not delete records for deleted object store") };
+            return { UnknownError, ASCIILiteral("Could not delete records for deleted object store") };
         }
     }
 
@@ -1022,7 +1021,7 @@ IDBError SQLiteIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
             || sql->bindInt64(1, objectStoreIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete index from IndexInfo table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not delete IDBIndex for deleted object store") };
+            return { UnknownError, ASCIILiteral("Could not delete IDBIndex for deleted object store") };
         }
     }
 
@@ -1033,7 +1032,7 @@ IDBError SQLiteIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
             || sql->bindInt64(1, objectStoreIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete index records(%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not delete IDBIndex records for deleted object store") };
+            return { UnknownError, ASCIILiteral("Could not delete IDBIndex records for deleted object store") };
         }
     }
 
@@ -1043,7 +1042,7 @@ IDBError SQLiteIDBBackingStore::deleteObjectStore(const IDBResourceIdentifier& t
         if (!sql
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete Blob URL records(%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not delete stored blob records for deleted object store") };
+            return { UnknownError, ASCIILiteral("Could not delete stored blob records for deleted object store") };
         }
     }
 
@@ -1067,11 +1066,11 @@ IDBError SQLiteIDBBackingStore::renameObjectStore(const IDBResourceIdentifier& t
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to rename an object store without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to rename an object store without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to rename an object store without an in-progress transaction") };
     }
     if (transaction->mode() != IDBTransactionMode::Versionchange) {
         LOG_ERROR("Attempt to rename an object store in a non-version-change transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to rename an object store in a non-version-change transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to rename an object store in a non-version-change transaction") };
     }
 
     {
@@ -1081,7 +1080,7 @@ IDBError SQLiteIDBBackingStore::renameObjectStore(const IDBResourceIdentifier& t
             || sql->bindInt64(2, objectStoreIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not update name for object store id %" PRIi64 " in ObjectStoreInfo table (%i) - %s", objectStoreIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not rename object store") };
+            return { UnknownError, ASCIILiteral("Could not rename object store") };
         }
     }
 
@@ -1100,11 +1099,11 @@ IDBError SQLiteIDBBackingStore::clearObjectStore(const IDBResourceIdentifier& tr
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to clear an object store without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to clear an object store without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to clear an object store without an in-progress transaction") };
     }
     if (transaction->mode() == IDBTransactionMode::Readonly) {
         LOG_ERROR("Attempt to clear an object store in a read-only transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to clear an object store in a read-only transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to clear an object store in a read-only transaction") };
     }
 
     {
@@ -1113,7 +1112,7 @@ IDBError SQLiteIDBBackingStore::clearObjectStore(const IDBResourceIdentifier& tr
             || sql->bindInt64(1, objectStoreID) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not clear records from object store id %" PRIi64 " (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to clear object store") };
+            return { UnknownError, ASCIILiteral("Unable to clear object store") };
         }
     }
 
@@ -1123,7 +1122,7 @@ IDBError SQLiteIDBBackingStore::clearObjectStore(const IDBResourceIdentifier& tr
             || sql->bindInt64(1, objectStoreID) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete records from index record store id %" PRIi64 " (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to delete index records while clearing object store") };
+            return { UnknownError, ASCIILiteral("Unable to delete index records while clearing object store") };
         }
     }
 
@@ -1141,17 +1140,17 @@ IDBError SQLiteIDBBackingStore::createIndex(const IDBResourceIdentifier& transac
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to create an index without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to create an index without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to create an index without an in-progress transaction") };
     }
     if (transaction->mode() != IDBTransactionMode::Versionchange) {
         LOG_ERROR("Attempt to create an index in a non-version-change transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to create an index in a non-version-change transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to create an index in a non-version-change transaction") };
     }
 
     RefPtr<SharedBuffer> keyPathBlob = serializeIDBKeyPath(info.keyPath());
     if (!keyPathBlob) {
         LOG_ERROR("Unable to serialize IDBKeyPath to save in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize IDBKeyPath to create index in database") };
+        return { UnknownError, ASCIILiteral("Unable to serialize IDBKeyPath to create index in database") };
     }
 
     auto* sql = cachedStatement(SQL::CreateIndexInfo, ASCIILiteral("INSERT INTO IndexInfo VALUES (?, ?, ?, ?, ?, ?);"));
@@ -1164,7 +1163,7 @@ IDBError SQLiteIDBBackingStore::createIndex(const IDBResourceIdentifier& transac
         || sql->bindInt(6, info.multiEntry()) != SQLITE_OK
         || sql->step() != SQLITE_DONE) {
         LOG_ERROR("Could not add index '%s' to IndexInfo table (%i) - %s", info.name().utf8().data(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to create index in database") };
+        return { UnknownError, ASCIILiteral("Unable to create index in database") };
     }
 
     // Write index records for any records that already exist in this object store.
@@ -1173,7 +1172,7 @@ IDBError SQLiteIDBBackingStore::createIndex(const IDBResourceIdentifier& transac
 
     if (!cursor) {
         LOG_ERROR("Cannot open cursor to populate indexes in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to populate indexes in database") };
+        return { UnknownError, ASCIILiteral("Unable to populate indexes in database") };
     }
 
     while (!cursor->currentKey().isNull()) {
@@ -1191,7 +1190,7 @@ IDBError SQLiteIDBBackingStore::createIndex(const IDBResourceIdentifier& transac
                 || sql->bindInt64(2, info.objectStoreIdentifier()) != SQLITE_OK
                 || sql->step() != SQLITE_DONE) {
                 LOG_ERROR("Index creation failed due to uniqueness constraint failure, but there was an error deleting the Index record from the database");
-                return { IDBDatabaseException::UnknownError, ASCIILiteral("Index creation failed due to uniqueness constraint failure, but there was an error deleting the Index record from the database") };
+                return { UnknownError, ASCIILiteral("Index creation failed due to uniqueness constraint failure, but there was an error deleting the Index record from the database") };
             }
 
             return error;
@@ -1199,7 +1198,7 @@ IDBError SQLiteIDBBackingStore::createIndex(const IDBResourceIdentifier& transac
 
         if (!cursor->advance(1)) {
             LOG_ERROR("Error advancing cursor while indexing existing records for new index.");
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error advancing cursor while indexing existing records for new index") };
+            return { UnknownError, ASCIILiteral("Error advancing cursor while indexing existing records for new index") };
         }
     }
 
@@ -1217,7 +1216,7 @@ IDBError SQLiteIDBBackingStore::uncheckedHasIndexRecord(const IDBIndexInfo& info
     RefPtr<SharedBuffer> indexKeyBuffer = serializeIDBKeyData(indexKey);
     if (!indexKeyBuffer) {
         LOG_ERROR("Unable to serialize index key to be stored in the database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize IDBKey to check for index record in database") };
+        return { UnknownError, ASCIILiteral("Unable to serialize IDBKey to check for index record in database") };
     }
 
     auto* sql = cachedStatement(SQL::HasIndexRecord, ASCIILiteral("SELECT rowid FROM IndexRecords WHERE indexID = ? AND objectStoreID = ? AND key = CAST(? AS TEXT);"));
@@ -1226,7 +1225,7 @@ IDBError SQLiteIDBBackingStore::uncheckedHasIndexRecord(const IDBIndexInfo& info
         || sql->bindInt64(2, info.objectStoreIdentifier()) != SQLITE_OK
         || sql->bindBlob(3, indexKeyBuffer->data(), indexKeyBuffer->size()) != SQLITE_OK) {
         LOG_ERROR("Error checking for index record in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error checking for index record in database") };
+        return { UnknownError, ASCIILiteral("Error checking for index record in database") };
     }
 
     int sqlResult = sql->step();
@@ -1236,7 +1235,7 @@ IDBError SQLiteIDBBackingStore::uncheckedHasIndexRecord(const IDBIndexInfo& info
     if (sqlResult != SQLITE_ROW) {
         // There was an error fetching the record from the database.
         LOG_ERROR("Could not check if key exists in index (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error checking for existence of IDBKey in index") };
+        return { UnknownError, ASCIILiteral("Error checking for existence of IDBKey in index") };
     }
 
     hasRecord = true;
@@ -1263,7 +1262,7 @@ IDBError SQLiteIDBBackingStore::uncheckedPutIndexKey(const IDBIndexInfo& info, c
             if (!error.isNull())
                 return error;
             if (hasRecord)
-                return IDBError(IDBDatabaseException::ConstraintError);
+                return IDBError(ConstraintError);
         }
     }
 
@@ -1287,13 +1286,13 @@ IDBError SQLiteIDBBackingStore::uncheckedPutIndexRecord(int64_t objectStoreID, i
     RefPtr<SharedBuffer> indexKeyBuffer = serializeIDBKeyData(indexKey);
     if (!indexKeyBuffer) {
         LOG_ERROR("Unable to serialize index key to be stored in the database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize index key to be stored in the database") };
+        return { UnknownError, ASCIILiteral("Unable to serialize index key to be stored in the database") };
     }
 
     RefPtr<SharedBuffer> valueBuffer = serializeIDBKeyData(keyValue);
     if (!valueBuffer) {
         LOG_ERROR("Unable to serialize the value to be stored in the database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize value to be stored in the database") };
+        return { UnknownError, ASCIILiteral("Unable to serialize value to be stored in the database") };
     }
 
     {
@@ -1306,7 +1305,7 @@ IDBError SQLiteIDBBackingStore::uncheckedPutIndexRecord(int64_t objectStoreID, i
             || sql->bindInt64(5, recordID) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not put index record for index %" PRIi64 " in object store %" PRIi64 " in Records table (%i) - %s", indexID, objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error putting index record into database") };
+            return { UnknownError, ASCIILiteral("Error putting index record into database") };
         }
     }
 
@@ -1324,12 +1323,12 @@ IDBError SQLiteIDBBackingStore::deleteIndex(const IDBResourceIdentifier& transac
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to delete index without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete index without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to delete index without an in-progress transaction") };
     }
 
     if (transaction->mode() != IDBTransactionMode::Versionchange) {
         LOG_ERROR("Attempt to delete index during a non-version-change transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete index during a non-version-change transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to delete index during a non-version-change transaction") };
     }
 
     {
@@ -1339,7 +1338,7 @@ IDBError SQLiteIDBBackingStore::deleteIndex(const IDBResourceIdentifier& transac
             || sql->bindInt64(2, objectStoreIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete index id %" PRIi64 " from IndexInfo table (%i) - %s", objectStoreIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error deleting index from database") };
+            return { UnknownError, ASCIILiteral("Error deleting index from database") };
         }
     }
 
@@ -1350,7 +1349,7 @@ IDBError SQLiteIDBBackingStore::deleteIndex(const IDBResourceIdentifier& transac
             || sql->bindInt64(2, objectStoreIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete index records for index id %" PRIi64 " from IndexRecords table (%i) - %s", indexIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error deleting index records from database") };
+            return { UnknownError, ASCIILiteral("Error deleting index records from database") };
         }
     }
 
@@ -1370,21 +1369,21 @@ IDBError SQLiteIDBBackingStore::renameIndex(const IDBResourceIdentifier& transac
 
     auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
     if (!objectStoreInfo)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not rename index") };
+        return { UnknownError, ASCIILiteral("Could not rename index") };
 
     auto* indexInfo = objectStoreInfo->infoForExistingIndex(indexIdentifier);
     if (!indexInfo)
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not rename index") };
+        return { UnknownError, ASCIILiteral("Could not rename index") };
 
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to rename an index without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to rename an index without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to rename an index without an in-progress transaction") };
     }
 
     if (transaction->mode() != IDBTransactionMode::Versionchange) {
         LOG_ERROR("Attempt to rename an index in a non-version-change transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to rename an index in a non-version-change transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to rename an index in a non-version-change transaction") };
     }
 
     {
@@ -1395,7 +1394,7 @@ IDBError SQLiteIDBBackingStore::renameIndex(const IDBResourceIdentifier& transac
             || sql->bindInt64(3, indexIdentifier) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not update name for index id (%" PRIi64 ", %" PRIi64 ") in IndexInfo table (%i) - %s", objectStoreIdentifier, indexIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not rename index") };
+            return { UnknownError, ASCIILiteral("Could not rename index") };
         }
     }
 
@@ -1416,20 +1415,20 @@ IDBError SQLiteIDBBackingStore::keyExistsInObjectStore(const IDBResourceIdentifi
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to see if key exists in objectstore without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to see if key exists in objectstore without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to see if key exists in objectstore without an in-progress transaction") };
     }
 
     RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);
     if (!keyBuffer) {
         LOG_ERROR("Unable to serialize IDBKey to check for existence in object store");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize IDBKey to check for existence in object store") };
+        return { UnknownError, ASCIILiteral("Unable to serialize IDBKey to check for existence in object store") };
     }
     auto* sql = cachedStatement(SQL::KeyExistsInObjectStore, ASCIILiteral("SELECT key FROM Records WHERE objectStoreID = ? AND key = CAST(? AS TEXT) LIMIT 1;"));
     if (!sql
         || sql->bindInt64(1, objectStoreID) != SQLITE_OK
         || sql->bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK) {
         LOG_ERROR("Could not get record from object store %" PRIi64 " from Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to check for existence of IDBKey in object store") };
+        return { UnknownError, ASCIILiteral("Unable to check for existence of IDBKey in object store") };
     }
 
     int sqlResult = sql->step();
@@ -1439,7 +1438,7 @@ IDBError SQLiteIDBBackingStore::keyExistsInObjectStore(const IDBResourceIdentifi
     if (sqlResult != SQLITE_ROW) {
         // There was an error fetching the record from the database.
         LOG_ERROR("Could not check if key exists in object store (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error checking for existence of IDBKey in object store") };
+        return { UnknownError, ASCIILiteral("Error checking for existence of IDBKey in object store") };
     }
 
     keyExists = true;
@@ -1457,7 +1456,7 @@ IDBError SQLiteIDBBackingStore::deleteUnusedBlobFileRecords(SQLiteIDBTransaction
 
         if (!sql) {
             LOG_ERROR("Error deleting stored blobs (%i) (Could not gather unused blobURLs) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error deleting stored blobs") };
+            return { UnknownError, ASCIILiteral("Error deleting stored blobs") };
         }
 
         int result = sql->step();
@@ -1468,7 +1467,7 @@ IDBError SQLiteIDBBackingStore::deleteUnusedBlobFileRecords(SQLiteIDBTransaction
 
         if (result != SQLITE_DONE) {
             LOG_ERROR("Error deleting stored blobs (%i) (Could not gather unused blobURLs) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error deleting stored blobs") };
+            return { UnknownError, ASCIILiteral("Error deleting stored blobs") };
         }
     }
 
@@ -1479,7 +1478,7 @@ IDBError SQLiteIDBBackingStore::deleteUnusedBlobFileRecords(SQLiteIDBTransaction
         if (!sql
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Error deleting stored blobs (%i) (Could not delete blobFile records) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error deleting stored blobs") };
+            return { UnknownError, ASCIILiteral("Error deleting stored blobs") };
         }
     }
 
@@ -1502,7 +1501,7 @@ IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction,
     RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);
     if (!keyBuffer) {
         LOG_ERROR("Unable to serialize IDBKeyData to be removed from the database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize IDBKeyData to be removed from the database") };
+        return { UnknownError, ASCIILiteral("Unable to serialize IDBKeyData to be removed from the database") };
     }
 
     // Get the record ID
@@ -1514,7 +1513,7 @@ IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction,
             || sql->bindInt64(1, objectStoreID) != SQLITE_OK
             || sql->bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK) {
             LOG_ERROR("Could not delete record from object store %" PRIi64 " (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to delete record from object store") };
+            return { UnknownError, ASCIILiteral("Failed to delete record from object store") };
         }
 
         int result = sql->step();
@@ -1525,7 +1524,7 @@ IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction,
 
         if (result != SQLITE_ROW) {
             LOG_ERROR("Could not delete record from object store %" PRIi64 " (%i) (unable to fetch record ID) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to delete record from object store") };
+            return { UnknownError, ASCIILiteral("Failed to delete record from object store") };
         }
 
         recordID = sql->getColumnInt64(0);
@@ -1533,7 +1532,7 @@ IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction,
 
     if (recordID < 1) {
         LOG_ERROR("Could not delete record from object store %" PRIi64 " (%i) (record ID is invalid) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to delete record from object store") };
+        return { UnknownError, ASCIILiteral("Failed to delete record from object store") };
     }
 
     // Delete the blob records for this object store record.
@@ -1544,7 +1543,7 @@ IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction,
             || sql->bindInt64(1, recordID) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete record from object store %" PRIi64 " (%i) (Could not delete BlobRecords records) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to delete record from object store") };
+            return { UnknownError, ASCIILiteral("Failed to delete record from object store") };
         }
     }
 
@@ -1561,7 +1560,7 @@ IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction,
             || sql->bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete record from object store %" PRIi64 " (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to delete record from object store") };
+            return { UnknownError, ASCIILiteral("Failed to delete record from object store") };
         }
     }
 
@@ -1574,7 +1573,7 @@ IDBError SQLiteIDBBackingStore::deleteRecord(SQLiteIDBTransaction& transaction,
             || sql->bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not delete record from indexes for object store %" PRIi64 " (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to delete index entries for object store record") };
+            return { UnknownError, ASCIILiteral("Failed to delete index entries for object store record") };
         }
     }
 
@@ -1591,11 +1590,11 @@ IDBError SQLiteIDBBackingStore::deleteRange(const IDBResourceIdentifier& transac
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to delete range from database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete range from database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to delete range from database without an in-progress transaction") };
     }
     if (transaction->mode() == IDBTransactionMode::Readonly) {
         LOG_ERROR("Attempt to delete records from an object store in a read-only transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete records from an object store in a read-only transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to delete records from an object store in a read-only transaction") };
     }
 
     // If the range to delete is exactly one key we can delete it right now.
@@ -1614,7 +1613,7 @@ IDBError SQLiteIDBBackingStore::deleteRange(const IDBResourceIdentifier& transac
     auto cursor = transaction->maybeOpenBackingStoreCursor(objectStoreID, 0, keyRange);
     if (!cursor) {
         LOG_ERROR("Cannot open cursor to delete range of records from the database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Cannot open cursor to delete range of records from the database") };
+        return { UnknownError, ASCIILiteral("Cannot open cursor to delete range of records from the database") };
     }
 
     Vector<IDBKeyData> keys;
@@ -1625,7 +1624,7 @@ IDBError SQLiteIDBBackingStore::deleteRange(const IDBResourceIdentifier& transac
 
     if (cursor->didError()) {
         LOG_ERROR("Cursor failed while accumulating range of records from the database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Cursor failed while accumulating range of records from the database") };
+        return { UnknownError, ASCIILiteral("Cursor failed while accumulating range of records from the database") };
     }
 
     IDBError error;
@@ -1693,7 +1692,7 @@ IDBError SQLiteIDBBackingStore::updateAllIndexesForAddRecord(const IDBObjectStor
             || sql->bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Adding one Index record failed, but failed to remove all others that previously succeeded");
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Adding one Index record failed, but failed to remove all others that previously succeeded") };
+            return { UnknownError, ASCIILiteral("Adding one Index record failed, but failed to remove all others that previously succeeded") };
         }
     }
 
@@ -1712,17 +1711,17 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to store a record in an object store without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to store a record in an object store without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to store a record in an object store without an in-progress transaction") };
     }
     if (transaction->mode() == IDBTransactionMode::Readonly) {
         LOG_ERROR("Attempt to store a record in an object store in a read-only transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to store a record in an object store in a read-only transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to store a record in an object store in a read-only transaction") };
     }
 
     RefPtr<SharedBuffer> keyBuffer = serializeIDBKeyData(keyData);
     if (!keyBuffer) {
         LOG_ERROR("Unable to serialize IDBKey to be stored in an object store");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize IDBKey to be stored in an object store") };
+        return { UnknownError, ASCIILiteral("Unable to serialize IDBKey to be stored in an object store") };
     }
 
     int64_t recordID = 0;
@@ -1734,7 +1733,7 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
             || sql->bindBlob(3, value.data().data()->data(), value.data().data()->size()) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Could not put record for object store %" PRIi64 " in Records table (%i) - %s", objectStoreInfo.identifier(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to store record in object store") };
+            return { UnknownError, ASCIILiteral("Unable to store record in object store") };
         }
 
         recordID = m_sqliteDB->lastInsertRowID();
@@ -1749,7 +1748,7 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
             || sql->bindBlob(2, keyBuffer->data(), keyBuffer->size()) != SQLITE_OK
             || sql->step() != SQLITE_DONE) {
             LOG_ERROR("Indexing new object store record failed, but unable to remove the object store record itself");
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Indexing new object store record failed, but unable to remove the object store record itself") };
+            return { UnknownError, ASCIILiteral("Indexing new object store record failed, but unable to remove the object store record itself") };
         }
 
         return error;
@@ -1766,7 +1765,7 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
                 || sql->bindText(2, url) != SQLITE_OK
                 || sql->step() != SQLITE_DONE) {
                 LOG_ERROR("Unable to record Blob record in database");
-                return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to record Blob record in database") };
+                return { UnknownError, ASCIILiteral("Unable to record Blob record in database") };
             }
         }
         int64_t potentialFileNameInteger = m_sqliteDB->lastInsertRowID();
@@ -1777,13 +1776,13 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
             if (!sql
                 || sql->bindText(1, url) != SQLITE_OK) {
                 LOG_ERROR("Unable to examine Blob filenames in database");
-                return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to examine Blob filenames in database") };
+                return { UnknownError, ASCIILiteral("Unable to examine Blob filenames in database") };
             }
 
             int result = sql->step();
             if (result != SQLITE_ROW && result != SQLITE_DONE) {
                 LOG_ERROR("Unable to examine Blob filenames in database");
-                return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to examine Blob filenames in database") };
+                return { UnknownError, ASCIILiteral("Unable to examine Blob filenames in database") };
             }
 
             if (result == SQLITE_ROW)
@@ -1799,7 +1798,7 @@ IDBError SQLiteIDBBackingStore::addRecord(const IDBResourceIdentifier& transacti
                 || sql->bindText(2, storedFilename) != SQLITE_OK
                 || sql->step() != SQLITE_DONE) {
                 LOG_ERROR("Unable to record Blob file record in database");
-                return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to record Blob file record in database") };
+                return { UnknownError, ASCIILiteral("Unable to record Blob file record in database") };
             }
         }
 
@@ -1821,7 +1820,7 @@ IDBError SQLiteIDBBackingStore::getBlobRecordsForObjectStoreRecord(int64_t objec
         if (!sql
             || sql->bindInt64(1, objectStoreRecord) != SQLITE_OK) {
             LOG_ERROR("Could not prepare statement to fetch blob URLs for object store record (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to look up blobURL records in object store by key range") };
+            return { UnknownError, ASCIILiteral("Failed to look up blobURL records in object store by key range") };
         }
 
         int sqlResult = sql->step();
@@ -1837,7 +1836,7 @@ IDBError SQLiteIDBBackingStore::getBlobRecordsForObjectStoreRecord(int64_t objec
 
         if (sqlResult != SQLITE_DONE) {
             LOG_ERROR("Could not fetch blob URLs for object store record (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to look up blobURL records in object store by key range") };
+            return { UnknownError, ASCIILiteral("Failed to look up blobURL records in object store by key range") };
         }
     }
 
@@ -1848,12 +1847,12 @@ IDBError SQLiteIDBBackingStore::getBlobRecordsForObjectStoreRecord(int64_t objec
         if (!sql
             || sql->bindText(1, blobURL) != SQLITE_OK) {
             LOG_ERROR("Could not prepare statement to fetch blob filename for object store record (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to look up blobURL records in object store by key range") };
+            return { UnknownError, ASCIILiteral("Failed to look up blobURL records in object store by key range") };
         }
 
         if (sql->step() != SQLITE_ROW) {
             LOG_ERROR("Entry for blob filename for blob url %s does not exist (%i) - %s", blobURL.utf8().data(), m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to look up blobURL records in object store by key range") };
+            return { UnknownError, ASCIILiteral("Failed to look up blobURL records in object store by key range") };
         }
 
         blobURLs.append(blobURL);
@@ -1875,7 +1874,7 @@ IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to get a record from database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to get a record from database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to get a record from database without an in-progress transaction") };
     }
 
     auto key = keyRange.lowerKey;
@@ -1884,7 +1883,7 @@ IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
     RefPtr<SharedBuffer> lowerBuffer = serializeIDBKeyData(key);
     if (!lowerBuffer) {
         LOG_ERROR("Unable to serialize lower IDBKey in lookup range");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize lower IDBKey in lookup range") };
+        return { UnknownError, ASCIILiteral("Unable to serialize lower IDBKey in lookup range") };
     }
 
     key = keyRange.upperKey;
@@ -1893,7 +1892,7 @@ IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
     RefPtr<SharedBuffer> upperBuffer = serializeIDBKeyData(key);
     if (!upperBuffer) {
         LOG_ERROR("Unable to serialize upper IDBKey in lookup range");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize upper IDBKey in lookup range") };
+        return { UnknownError, ASCIILiteral("Unable to serialize upper IDBKey in lookup range") };
     }
 
     int64_t recordID = 0;
@@ -1944,7 +1943,7 @@ IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
             || sql->bindBlob(2, lowerBuffer->data(), lowerBuffer->size()) != SQLITE_OK
             || sql->bindBlob(3, upperBuffer->data(), upperBuffer->size()) != SQLITE_OK) {
             LOG_ERROR("Could not get key range record from object store %" PRIi64 " from Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to look up record in object store by key range") };
+            return { UnknownError, ASCIILiteral("Failed to look up record in object store by key range") };
         }
 
         int sqlResult = sql->step();
@@ -1956,7 +1955,7 @@ IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
         if (sqlResult != SQLITE_ROW) {
             // There was an error fetching the record from the database.
             LOG_ERROR("Could not get record from object store %" PRIi64 " from Records table (%i) - %s", objectStoreID, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error looking up record in object store by key range") };
+            return { UnknownError, ASCIILiteral("Error looking up record in object store by key range") };
         }
 
         Vector<uint8_t> buffer;
@@ -1971,13 +1970,13 @@ IDBError SQLiteIDBBackingStore::getRecord(const IDBResourceIdentifier& transacti
         auto* vector = resultBuffer.data();
         if (!vector) {
             LOG_ERROR("Unable to deserialize key data from database for IDBObjectStore.getKey()");
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error extracting key data from database executing IDBObjectStore.getKey()") };
+            return { UnknownError, ASCIILiteral("Error extracting key data from database executing IDBObjectStore.getKey()") };
         }
 
         IDBKeyData keyData;
         if (!deserializeIDBKeyData(vector->data(), vector->size(), keyData)) {
             LOG_ERROR("Unable to deserialize key data from database for IDBObjectStore.getKey()");
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Error extracting key data from database executing IDBObjectStore.getKey()") };
+            return { UnknownError, ASCIILiteral("Error extracting key data from database executing IDBObjectStore.getKey()") };
         }
 
         resultValue = { keyData };
@@ -2045,7 +2044,7 @@ IDBError SQLiteIDBBackingStore::getAllObjectStoreRecords(const IDBResourceIdenti
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to get records from database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to get records from database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to get records from database without an in-progress transaction") };
     }
 
     auto key = getAllRecordsData.keyRangeData.lowerKey;
@@ -2054,7 +2053,7 @@ IDBError SQLiteIDBBackingStore::getAllObjectStoreRecords(const IDBResourceIdenti
     auto lowerBuffer = serializeIDBKeyData(key);
     if (!lowerBuffer) {
         LOG_ERROR("Unable to serialize lower IDBKey in lookup range");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize lower IDBKey in lookup range") };
+        return { UnknownError, ASCIILiteral("Unable to serialize lower IDBKey in lookup range") };
     }
 
     key = getAllRecordsData.keyRangeData.upperKey;
@@ -2063,7 +2062,7 @@ IDBError SQLiteIDBBackingStore::getAllObjectStoreRecords(const IDBResourceIdenti
     auto upperBuffer = serializeIDBKeyData(key);
     if (!upperBuffer) {
         LOG_ERROR("Unable to serialize upper IDBKey in lookup range");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize upper IDBKey in lookup range") };
+        return { UnknownError, ASCIILiteral("Unable to serialize upper IDBKey in lookup range") };
     }
 
     auto* sql = cachedStatementForGetAllObjectStoreRecords(getAllRecordsData);
@@ -2072,7 +2071,7 @@ IDBError SQLiteIDBBackingStore::getAllObjectStoreRecords(const IDBResourceIdenti
         || sql->bindBlob(2, lowerBuffer->data(), lowerBuffer->size()) != SQLITE_OK
         || sql->bindBlob(3, upperBuffer->data(), upperBuffer->size()) != SQLITE_OK) {
         LOG_ERROR("Could not get key range record from object store %" PRIi64 " from Records table (%i) - %s", getAllRecordsData.objectStoreIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Failed to look up record in object store by key range") };
+        return { UnknownError, ASCIILiteral("Failed to look up record in object store by key range") };
     }
 
     result = { getAllRecordsData.getAllType };
@@ -2110,7 +2109,7 @@ IDBError SQLiteIDBBackingStore::getAllObjectStoreRecords(const IDBResourceIdenti
 
             if (!deserializeIDBKeyData(keyData.data(), keyData.size(), key)) {
                 LOG_ERROR("Unable to deserialize key data from database while getting all key records");
-                return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to deserialize key data while getting all key records") };
+                return { UnknownError, ASCIILiteral("Unable to deserialize key data while getting all key records") };
             }
 
             result.addKey(WTFMove(key));
@@ -2127,7 +2126,7 @@ IDBError SQLiteIDBBackingStore::getAllObjectStoreRecords(const IDBResourceIdenti
 
     // There was an error fetching records from the database.
     LOG_ERROR("Could not get record from object store %" PRIi64 " from Records table (%i) - %s", getAllRecordsData.objectStoreIdentifier, m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-    return { IDBDatabaseException::UnknownError, ASCIILiteral("Error looking up record in object store by key range") };
+    return { UnknownError, ASCIILiteral("Error looking up record in object store by key range") };
 }
 
 IDBError SQLiteIDBBackingStore::getAllIndexRecords(const IDBResourceIdentifier& transactionIdentifier, const IDBGetAllRecordsData& getAllRecordsData, IDBGetAllResult& result)
@@ -2140,18 +2139,18 @@ IDBError SQLiteIDBBackingStore::getAllIndexRecords(const IDBResourceIdentifier&
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to get all index records from database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to get all index records from database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to get all index records from database without an in-progress transaction") };
     }
 
     auto cursor = transaction->maybeOpenBackingStoreCursor(getAllRecordsData.objectStoreIdentifier, getAllRecordsData.indexIdentifier, getAllRecordsData.keyRangeData);
     if (!cursor) {
         LOG_ERROR("Cannot open cursor to perform index gets in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Cannot open cursor to perform index gets in database") };
+        return { UnknownError, ASCIILiteral("Cannot open cursor to perform index gets in database") };
     }
 
     if (cursor->didError()) {
         LOG_ERROR("Cursor failed while looking up index records in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Cursor failed while looking up index records in database") };
+        return { UnknownError, ASCIILiteral("Cursor failed while looking up index records in database") };
     }
 
     result = { getAllRecordsData.getAllType };
@@ -2172,7 +2171,7 @@ IDBError SQLiteIDBBackingStore::getAllIndexRecords(const IDBResourceIdentifier&
 
     if (cursor->didError()) {
         LOG_ERROR("Cursor failed while looking up index records in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Cursor failed while looking up index records in database") };
+        return { UnknownError, ASCIILiteral("Cursor failed while looking up index records in database") };
     }
 
     return { };
@@ -2188,7 +2187,7 @@ IDBError SQLiteIDBBackingStore::getIndexRecord(const IDBResourceIdentifier& tran
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to get an index record from database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to get an index record from database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to get an index record from database without an in-progress transaction") };
     }
 
     if (range.isExactlyOneKey())
@@ -2197,12 +2196,12 @@ IDBError SQLiteIDBBackingStore::getIndexRecord(const IDBResourceIdentifier& tran
     auto cursor = transaction->maybeOpenBackingStoreCursor(objectStoreID, indexID, range);
     if (!cursor) {
         LOG_ERROR("Cannot open cursor to perform index get in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Cannot open cursor to perform index get in database") };
+        return { UnknownError, ASCIILiteral("Cannot open cursor to perform index get in database") };
     }
 
     if (cursor->didError()) {
         LOG_ERROR("Cursor failed while looking up index record in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Cursor failed while looking up index record in database") };
+        return { UnknownError, ASCIILiteral("Cursor failed while looking up index record in database") };
     }
 
     if (cursor->didComplete())
@@ -2226,7 +2225,7 @@ IDBError SQLiteIDBBackingStore::uncheckedGetIndexRecordForOneKey(int64_t indexID
     RefPtr<SharedBuffer> buffer = serializeIDBKeyData(key);
     if (!buffer) {
         LOG_ERROR("Unable to serialize IDBKey to look up one index record");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to serialize IDBKey to look up one index record") };
+        return { UnknownError, ASCIILiteral("Unable to serialize IDBKey to look up one index record") };
     }
 
     auto* sql = cachedStatement(SQL::GetIndexRecordForOneKey, ASCIILiteral("SELECT IndexRecords.value, Records.value, Records.recordID FROM Records INNER JOIN IndexRecords ON Records.recordID = IndexRecords.objectStoreRecordID WHERE IndexRecords.indexID = ? AND IndexRecords.objectStoreID = ? AND IndexRecords.key = CAST(? AS TEXT) ORDER BY IndexRecords.key, IndexRecords.value"));
@@ -2236,13 +2235,13 @@ IDBError SQLiteIDBBackingStore::uncheckedGetIndexRecordForOneKey(int64_t indexID
         || sql->bindInt64(2, objectStoreID) != SQLITE_OK
         || sql->bindBlob(3, buffer->data(), buffer->size()) != SQLITE_OK) {
         LOG_ERROR("Unable to lookup index record in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to lookup index record in database") };
+        return { UnknownError, ASCIILiteral("Unable to lookup index record in database") };
     }
 
     int result = sql->step();
     if (result != SQLITE_ROW && result != SQLITE_DONE) {
         LOG_ERROR("Unable to lookup index record in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to lookup index record in database") };
+        return { UnknownError, ASCIILiteral("Unable to lookup index record in database") };
     }
 
     if (result == SQLITE_DONE)
@@ -2254,7 +2253,7 @@ IDBError SQLiteIDBBackingStore::uncheckedGetIndexRecordForOneKey(int64_t indexID
 
     if (!deserializeIDBKeyData(keyVector.data(), keyVector.size(), objectStoreKey)) {
         LOG_ERROR("Unable to deserialize key looking up index record in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to deserialize key looking up index record in database") };
+        return { UnknownError, ASCIILiteral("Unable to deserialize key looking up index record in database") };
     }
 
     if (type == IndexedDB::IndexRecordType::Key) {
@@ -2287,13 +2286,13 @@ IDBError SQLiteIDBBackingStore::getCount(const IDBResourceIdentifier& transactio
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to get count from database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to get count from database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to get count from database without an in-progress transaction") };
     }
 
     auto cursor = transaction->maybeOpenBackingStoreCursor(objectStoreIdentifier, indexIdentifier, range);
     if (!cursor) {
         LOG_ERROR("Cannot open cursor to populate indexes in database");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to populate indexes in database") };
+        return { UnknownError, ASCIILiteral("Unable to populate indexes in database") };
     }
 
     while (cursor->advance(1))
@@ -2308,17 +2307,17 @@ IDBError SQLiteIDBBackingStore::uncheckedGetKeyGeneratorValue(int64_t objectStor
     if (!sql
         || sql->bindInt64(1, objectStoreID) != SQLITE_OK) {
         LOG_ERROR("Could not retrieve currentKey from KeyGenerators table (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error getting current key generator value from database") };
+        return { UnknownError, ASCIILiteral("Error getting current key generator value from database") };
     }
     int result = sql->step();
     if (result != SQLITE_ROW) {
         LOG_ERROR("Could not retreive key generator value for object store, but it should be there.");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Error finding current key generator value in database") };
+        return { UnknownError, ASCIILiteral("Error finding current key generator value in database") };
     }
 
     int64_t value = sql->getColumnInt64(0);
     if (value < 0)
-        return { IDBDatabaseException::ConstraintError, "Current key generator value from database is invalid" };
+        return { ConstraintError, "Current key generator value from database is invalid" };
 
     outValue = value;
     return { };
@@ -2332,7 +2331,7 @@ IDBError SQLiteIDBBackingStore::uncheckedSetKeyGeneratorValue(int64_t objectStor
         || sql->bindInt64(2, value) != SQLITE_OK
         || sql->step() != SQLITE_DONE) {
         LOG_ERROR("Could not update key generator value (%i) - %s", m_sqliteDB->lastError(), m_sqliteDB->lastErrorMsg());
-        return { IDBDatabaseException::ConstraintError, "Error storing new key generator value in database" };
+        return { ConstraintError, "Error storing new key generator value in database" };
     }
 
     return { };
@@ -2351,11 +2350,11 @@ IDBError SQLiteIDBBackingStore::generateKeyNumber(const IDBResourceIdentifier& t
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to generate key in database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to generate key in database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to generate key in database without an in-progress transaction") };
     }
     if (transaction->mode() == IDBTransactionMode::Readonly) {
         LOG_ERROR("Attempt to generate key in a read-only transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to generate key in a read-only transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to generate key in a read-only transaction") };
     }
 
     uint64_t currentValue;
@@ -2364,7 +2363,7 @@ IDBError SQLiteIDBBackingStore::generateKeyNumber(const IDBResourceIdentifier& t
         return error;
 
     if (currentValue + 1 > maxGeneratorValue)
-        return { IDBDatabaseException::ConstraintError, "Cannot generate new key value over 2^53 for object store operation" };
+        return { ConstraintError, "Cannot generate new key value over 2^53 for object store operation" };
 
     generatedKey = currentValue + 1;
     return uncheckedSetKeyGeneratorValue(objectStoreID, generatedKey);
@@ -2380,11 +2379,11 @@ IDBError SQLiteIDBBackingStore::revertGeneratedKeyNumber(const IDBResourceIdenti
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to revert key generator value in database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to revert key generator value in database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to revert key generator value in database without an in-progress transaction") };
     }
     if (transaction->mode() == IDBTransactionMode::Readonly) {
         LOG_ERROR("Attempt to revert key generator value in a read-only transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to revert key generator value in a read-only transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to revert key generator value in a read-only transaction") };
     }
 
     ASSERT(newKeyNumber);
@@ -2401,11 +2400,11 @@ IDBError SQLiteIDBBackingStore::maybeUpdateKeyGeneratorNumber(const IDBResourceI
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to update key generator value in database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to update key generator value in database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to update key generator value in database without an in-progress transaction") };
     }
     if (transaction->mode() == IDBTransactionMode::Readonly) {
         LOG_ERROR("Attempt to update key generator value in a read-only transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to update key generator value in a read-only transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to update key generator value in a read-only transaction") };
     }
 
     uint64_t currentValue;
@@ -2433,13 +2432,13 @@ IDBError SQLiteIDBBackingStore::openCursor(const IDBResourceIdentifier& transact
     auto* transaction = m_transactions.get(transactionIdentifier);
     if (!transaction || !transaction->inProgress()) {
         LOG_ERROR("Attempt to open a cursor in database without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to open a cursor in database without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to open a cursor in database without an in-progress transaction") };
     }
 
     auto* cursor = transaction->maybeOpenCursor(info);
     if (!cursor) {
         LOG_ERROR("Unable to open cursor");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to open cursor") };
+        return { UnknownError, ASCIILiteral("Unable to open cursor") };
     }
 
     m_cursors.set(cursor->identifier(), cursor);
@@ -2458,14 +2457,14 @@ IDBError SQLiteIDBBackingStore::iterateCursor(const IDBResourceIdentifier& trans
     auto* cursor = m_cursors.get(cursorIdentifier);
     if (!cursor) {
         LOG_ERROR("Attempt to iterate a cursor that doesn't exist");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to iterate a cursor that doesn't exist") };
+        return { UnknownError, ASCIILiteral("Attempt to iterate a cursor that doesn't exist") };
     }
 
     ASSERT_UNUSED(transactionIdentifier, cursor->transaction()->transactionIdentifier() == transactionIdentifier);
 
     if (!cursor->transaction() || !cursor->transaction()->inProgress()) {
         LOG_ERROR("Attempt to iterate a cursor without an in-progress transaction");
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to iterate a cursor without an in-progress transaction") };
+        return { UnknownError, ASCIILiteral("Attempt to iterate a cursor without an in-progress transaction") };
     }
 
     auto key = data.keyData;
@@ -2475,7 +2474,7 @@ IDBError SQLiteIDBBackingStore::iterateCursor(const IDBResourceIdentifier& trans
     if (key.isValid()) {
         if (!cursor->iterate(key, primaryKey)) {
             LOG_ERROR("Attempt to iterate cursor failed");
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to iterate cursor failed") };
+            return { UnknownError, ASCIILiteral("Attempt to iterate cursor failed") };
         }
     } else {
         ASSERT(!primaryKey.isValid());
@@ -2483,7 +2482,7 @@ IDBError SQLiteIDBBackingStore::iterateCursor(const IDBResourceIdentifier& trans
             count = 1;
         if (!cursor->advance(count)) {
             LOG_ERROR("Attempt to advance cursor failed");
-            return { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to advance cursor failed") };
+            return { UnknownError, ASCIILiteral("Attempt to advance cursor failed") };
         }
     }
 
index fc1dd17..b7efafa 100644 (file)
@@ -64,19 +64,19 @@ IDBError SQLiteIDBTransaction::begin(SQLiteDatabase& database)
     if (m_sqliteTransaction->inProgress())
         return { };
 
-    return { IDBDatabaseException::UnknownError, ASCIILiteral("Could not start SQLite transaction in database backend") };
+    return { UnknownError, ASCIILiteral("Could not start SQLite transaction in database backend") };
 }
 
 IDBError SQLiteIDBTransaction::commit()
 {
     LOG(IndexedDB, "SQLiteIDBTransaction::commit");
     if (!m_sqliteTransaction || !m_sqliteTransaction->inProgress())
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No SQLite transaction in progress to commit") };
+        return { UnknownError, ASCIILiteral("No SQLite transaction in progress to commit") };
 
     m_sqliteTransaction->commit();
 
     if (m_sqliteTransaction->inProgress())
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to commit SQLite transaction in database backend") };
+        return { UnknownError, ASCIILiteral("Unable to commit SQLite transaction in database backend") };
 
     deleteBlobFilesIfNecessary();
     moveBlobFilesIfNecessary();
@@ -125,12 +125,12 @@ IDBError SQLiteIDBTransaction::abort()
     m_blobTemporaryAndStoredFilenames.clear();
 
     if (!m_sqliteTransaction || !m_sqliteTransaction->inProgress())
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("No SQLite transaction in progress to abort") };
+        return { UnknownError, ASCIILiteral("No SQLite transaction in progress to abort") };
 
     m_sqliteTransaction->rollback();
 
     if (m_sqliteTransaction->inProgress())
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Unable to abort SQLite transaction in database backend") };
+        return { UnknownError, ASCIILiteral("Unable to abort SQLite transaction in database backend") };
 
     reset();
     return { };
index c98f7b0..99542f8 100644 (file)
@@ -153,7 +153,7 @@ void UniqueIDBDatabase::performCurrentOpenOperation()
     // 3.3.1 Opening a database
     // If the database version higher than the requested version, abort these steps and return a VersionError.
     if (requestedVersion < m_databaseInfo->version()) {
-        auto result = IDBResultData::error(m_currentOpenDBRequest->requestData().requestIdentifier(), IDBError(IDBDatabaseException::VersionError));
+        auto result = IDBResultData::error(m_currentOpenDBRequest->requestData().requestIdentifier(), IDBError(VersionError));
         m_currentOpenDBRequest->connection().didOpenDatabase(result);
         m_currentOpenDBRequest = nullptr;
 
@@ -694,7 +694,7 @@ void UniqueIDBDatabase::deleteObjectStore(UniqueIDBDatabaseTransaction& transact
 
     auto* info = m_databaseInfo->infoForExistingObjectStore(objectStoreName);
     if (!info) {
-        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete non-existant object store") });
+        performErrorCallback(callbackID, { UnknownError, ASCIILiteral("Attempt to delete non-existant object store") });
         return;
     }
 
@@ -735,7 +735,7 @@ void UniqueIDBDatabase::renameObjectStore(UniqueIDBDatabaseTransaction& transact
 
     auto* info = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
     if (!info) {
-        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to rename non-existant object store") });
+        performErrorCallback(callbackID, { UnknownError, ASCIILiteral("Attempt to rename non-existant object store") });
         return;
     }
 
@@ -844,13 +844,13 @@ void UniqueIDBDatabase::deleteIndex(UniqueIDBDatabaseTransaction& transaction, u
 
     auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
     if (!objectStoreInfo) {
-        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete index from non-existant object store") });
+        performErrorCallback(callbackID, { UnknownError, ASCIILiteral("Attempt to delete index from non-existant object store") });
         return;
     }
 
     auto* indexInfo = objectStoreInfo->infoForExistingIndex(indexName);
     if (!indexInfo) {
-        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to delete non-existant index") });
+        performErrorCallback(callbackID, { UnknownError, ASCIILiteral("Attempt to delete non-existant index") });
         return;
     }
 
@@ -894,13 +894,13 @@ void UniqueIDBDatabase::renameIndex(UniqueIDBDatabaseTransaction& transaction, u
 
     auto* objectStoreInfo = m_databaseInfo->infoForExistingObjectStore(objectStoreIdentifier);
     if (!objectStoreInfo) {
-        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to rename index in non-existant object store") });
+        performErrorCallback(callbackID, { UnknownError, ASCIILiteral("Attempt to rename index in non-existant object store") });
         return;
     }
 
     auto* indexInfo = objectStoreInfo->infoForExistingIndex(indexIdentifier);
     if (!indexInfo) {
-        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to rename non-existant index") });
+        performErrorCallback(callbackID, { UnknownError, ASCIILiteral("Attempt to rename non-existant index") });
         return;
     }
 
@@ -978,7 +978,7 @@ void UniqueIDBDatabase::performPutOrAdd(uint64_t callbackIdentifier, const IDBRe
 
     auto* objectStoreInfo = m_backingStore->infoForObjectStore(objectStoreIdentifier);
     if (!objectStoreInfo) {
-        error = IDBError(IDBDatabaseException::InvalidStateError, ASCIILiteral("Object store cannot be found in the backing store"));
+        error = IDBError(INVALID_STATE_ERR, ASCIILiteral("Object store cannot be found in the backing store"));
         postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, error, usedKey));
         return;
     }
@@ -1005,7 +1005,7 @@ void UniqueIDBDatabase::performPutOrAdd(uint64_t callbackIdentifier, const IDBRe
         bool keyExists;
         error = m_backingStore->keyExistsInObjectStore(transactionIdentifier, objectStoreIdentifier, usedKey, keyExists);
         if (error.isNull() && keyExists)
-            error = IDBError(IDBDatabaseException::ConstraintError, ASCIILiteral("Key already exists in the object store"));
+            error = IDBError(ConstraintError, ASCIILiteral("Key already exists in the object store"));
 
         if (!error.isNull()) {
             postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, error, usedKey));
@@ -1024,18 +1024,18 @@ void UniqueIDBDatabase::performPutOrAdd(uint64_t callbackIdentifier, const IDBRe
 
         auto value = deserializeIDBValueToJSValue(databaseThreadExecState(), originalRecordValue.data());
         if (value.isUndefined()) {
-            postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, IDBError(IDBDatabaseException::ConstraintError, ASCIILiteral("Unable to deserialize record value for record key injection")), usedKey));
+            postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, IDBError(ConstraintError, ASCIILiteral("Unable to deserialize record value for record key injection")), usedKey));
             return;
         }
 
         if (!injectIDBKeyIntoScriptValue(databaseThreadExecState(), usedKey, value, objectStoreInfo->keyPath().value())) {
-            postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, IDBError(IDBDatabaseException::ConstraintError, ASCIILiteral("Unable to inject record key into record value")), usedKey));
+            postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, IDBError(ConstraintError, ASCIILiteral("Unable to inject record key into record value")), usedKey));
             return;
         }
 
         auto serializedValue = SerializedScriptValue::create(databaseThreadExecState(), value);
         if (UNLIKELY(scope.exception())) {
-            postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, IDBError(IDBDatabaseException::ConstraintError, ASCIILiteral("Unable to serialize record value after injecting record key")), usedKey));
+            postDatabaseTaskReply(createCrossThreadTask(*this, &UniqueIDBDatabase::didPerformPutOrAdd, callbackIdentifier, IDBError(ConstraintError, ASCIILiteral("Unable to serialize record value after injecting record key")), usedKey));
             return;
         }
 
@@ -1329,7 +1329,7 @@ void UniqueIDBDatabase::commitTransaction(UniqueIDBDatabaseTransaction& transact
             return;
         }
 
-        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to commit transaction that is already finishing") });
+        performErrorCallback(callbackID, { UnknownError, ASCIILiteral("Attempt to commit transaction that is already finishing") });
         return;
     }
 
@@ -1373,7 +1373,7 @@ void UniqueIDBDatabase::abortTransaction(UniqueIDBDatabaseTransaction& transacti
             return;
         }
 
-        performErrorCallback(callbackID, { IDBDatabaseException::UnknownError, ASCIILiteral("Attempt to abort transaction that is already finishing") });
+        performErrorCallback(callbackID, { UnknownError, ASCIILiteral("Attempt to abort transaction that is already finishing") });
         return;
     }
 
index 7da9486..3a8986c 100644 (file)
@@ -28,6 +28,8 @@
 
 #if ENABLE(INDEXED_DATABASE)
 
+#include "ExceptionCodeDescription.h"
+
 namespace WebCore {
 
 IDBError::IDBError(ExceptionCode code)
@@ -55,17 +57,17 @@ IDBError& IDBError::operator=(const IDBError& other)
 
 String IDBError::name() const
 {
-    return IDBDatabaseException::getErrorName(m_code);
+    return ExceptionCodeDescription(m_code).name;
 }
 
 String IDBError::message() const
 {
-    return IDBDatabaseException::getErrorDescription(m_code);
+    return ExceptionCodeDescription(m_code).description;
 }
 
 RefPtr<DOMError> IDBError::toDOMError() const
 {
-    return DOMError::create(IDBDatabaseException::getErrorName(m_code), m_message);
+    return DOMError::create(name(), m_message);
 }
 
 } // namespace WebCore
index bb5531b..810da4c 100644 (file)
@@ -28,7 +28,7 @@
 #if ENABLE(INDEXED_DATABASE)
 
 #include "DOMError.h"
-#include "IDBDatabaseException.h"
+#include "ExceptionCode.h"
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
@@ -41,7 +41,7 @@ public:
 
     static IDBError userDeleteError()
     {
-        return { IDBDatabaseException::UnknownError, ASCIILiteral("Database deleted by request of the user") };
+        return { UnknownError, ASCIILiteral("Database deleted by request of the user") };
     }
 
     IDBError& operator=(const IDBError&);
@@ -52,7 +52,7 @@ public:
     String name() const;
     String message() const;
 
-    bool isNull() const { return m_code == IDBDatabaseException::NoError; }
+    bool isNull() const { return !m_code; }
 
     IDBError isolatedCopy() const;
 
@@ -60,7 +60,7 @@ public:
     template<class Decoder> static bool decode(Decoder&, IDBError&);
 
 private:
-    ExceptionCode m_code { IDBDatabaseException::NoError };
+    ExceptionCode m_code { 0 };
     String m_message;
 };
 
index 62fcd4d..d767f04 100644 (file)
                5185FC7E1BB4C4E80012898F /* IDBCursorWithValue.h in Headers */ = {isa = PBXBuildFile; fileRef = 51645B431B9F889B00F789CE /* IDBCursorWithValue.h */; };
                5185FC801BB4C4E80012898F /* IDBDatabase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51645B441B9F889B00F789CE /* IDBDatabase.cpp */; };
                5185FC811BB4C4E80012898F /* IDBDatabase.h in Headers */ = {isa = PBXBuildFile; fileRef = 51645B451B9F889B00F789CE /* IDBDatabase.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               5185FC831BB4C4E80012898F /* IDBDatabaseError.h in Headers */ = {isa = PBXBuildFile; fileRef = 51D71983181106DF0016DC51 /* IDBDatabaseError.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               5185FC841BB4C4E80012898F /* IDBDatabaseException.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51D71984181106DF0016DC51 /* IDBDatabaseException.cpp */; };
-               5185FC851BB4C4E80012898F /* IDBDatabaseException.h in Headers */ = {isa = PBXBuildFile; fileRef = 51D71985181106DF0016DC51 /* IDBDatabaseException.h */; settings = {ATTRIBUTES = (Private, ); }; };
                5185FC861BB4C4E80012898F /* IDBDatabaseIdentifier.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5103105E1BA8E090003329C0 /* IDBDatabaseIdentifier.cpp */; };
                5185FC871BB4C4E80012898F /* IDBDatabaseIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 5103105F1BA8E090003329C0 /* IDBDatabaseIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
                5185FC8A1BB4C4E80012898F /* IDBEventDispatcher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51D71986181106DF0016DC51 /* IDBEventDispatcher.cpp */; };
                51D71977181106DF0016DC51 /* IDBCursor.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = IDBCursor.idl; sourceTree = "<group>"; };
                51D7197B181106DF0016DC51 /* IDBCursorWithValue.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = IDBCursorWithValue.idl; sourceTree = "<group>"; };
                51D7197E181106DF0016DC51 /* IDBDatabase.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = IDBDatabase.idl; sourceTree = "<group>"; };
-               51D71983181106DF0016DC51 /* IDBDatabaseError.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBDatabaseError.h; sourceTree = "<group>"; };
-               51D71984181106DF0016DC51 /* IDBDatabaseException.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBDatabaseException.cpp; sourceTree = "<group>"; };
-               51D71985181106DF0016DC51 /* IDBDatabaseException.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBDatabaseException.h; sourceTree = "<group>"; };
                51D71986181106DF0016DC51 /* IDBEventDispatcher.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = IDBEventDispatcher.cpp; sourceTree = "<group>"; };
                51D71987181106DF0016DC51 /* IDBEventDispatcher.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = IDBEventDispatcher.h; sourceTree = "<group>"; };
                51D7198A181106DF0016DC51 /* IDBFactory.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = IDBFactory.idl; sourceTree = "<group>"; };
                                51645B441B9F889B00F789CE /* IDBDatabase.cpp */,
                                51645B451B9F889B00F789CE /* IDBDatabase.h */,
                                51D7197E181106DF0016DC51 /* IDBDatabase.idl */,
-                               51D71983181106DF0016DC51 /* IDBDatabaseError.h */,
-                               51D71984181106DF0016DC51 /* IDBDatabaseException.cpp */,
-                               51D71985181106DF0016DC51 /* IDBDatabaseException.h */,
                                5103105E1BA8E090003329C0 /* IDBDatabaseIdentifier.cpp */,
                                5103105F1BA8E090003329C0 /* IDBDatabaseIdentifier.h */,
                                51D71986181106DF0016DC51 /* IDBEventDispatcher.cpp */,
                                5110FCFC1E03641D006F8D0B /* IDBCursorRecord.h in Headers */,
                                5185FC7E1BB4C4E80012898F /* IDBCursorWithValue.h in Headers */,
                                5185FC811BB4C4E80012898F /* IDBDatabase.h in Headers */,
-                               5185FC831BB4C4E80012898F /* IDBDatabaseError.h in Headers */,
-                               5185FC851BB4C4E80012898F /* IDBDatabaseException.h in Headers */,
                                5185FC871BB4C4E80012898F /* IDBDatabaseIdentifier.h in Headers */,
                                51BA4AC41BBB5CD800DF3D6D /* IDBDatabaseInfo.h in Headers */,
                                5148453F1BB9D07E006A72ED /* IDBError.h in Headers */,
                                517138FB1BF3ADF4000D5F01 /* IDBCursorInfo.cpp in Sources */,
                                5185FC7D1BB4C4E80012898F /* IDBCursorWithValue.cpp in Sources */,
                                5185FC801BB4C4E80012898F /* IDBDatabase.cpp in Sources */,
-                               5185FC841BB4C4E80012898F /* IDBDatabaseException.cpp in Sources */,
                                5185FC861BB4C4E80012898F /* IDBDatabaseIdentifier.cpp in Sources */,
                                51BA4AC31BBB5CD800DF3D6D /* IDBDatabaseInfo.cpp in Sources */,
                                5148453E1BB9D07E006A72ED /* IDBError.cpp in Sources */,
index 5ff82ff..11e8d5f 100644 (file)
 #include <runtime/ExceptionHelpers.h>
 #include <wtf/text/StringBuilder.h>
 
-#if ENABLE(INDEXED_DATABASE)
-#include "IDBDatabaseException.h"
-#endif
-
 using namespace JSC;
 
 namespace WebCore {
@@ -166,15 +162,7 @@ static JSValue createDOMException(ExecState* exec, ExceptionCode ec, const Strin
         description.description = messageCString.data();
     }
 
-    JSValue errorObject;
-    switch (description.type) {
-    case DOMExceptionType:
-#if ENABLE(INDEXED_DATABASE)
-    case IDBDatabaseExceptionType:
-#endif
-        errorObject = toJS(exec, globalObject, DOMException::create(description));
-        break;
-    }
+    JSValue errorObject = toJS(exec, globalObject, DOMException::create(description));
     
     ASSERT(errorObject);
     addErrorInfo(exec, asObject(errorObject), true);
index ddbda92..3434a4e 100644 (file)
@@ -99,14 +99,18 @@ DOMException::DOMException(ExceptionCode ec, const String& message, const String
 bool DOMException::initializeDescription(ExceptionCode ec, ExceptionCodeDescription* description)
 {
     description->typeName = "DOM";
-    description->code = ec;
-    description->type = DOMExceptionType;
 
-    size_t tableSize = WTF_ARRAY_LENGTH(coreExceptions);
     size_t tableIndex = ec - INDEX_SIZE_ERR;
-
-    description->name = tableIndex < tableSize ? coreExceptions[tableIndex].name : 0;
-    description->description = tableIndex < tableSize ? coreExceptions[tableIndex].description : 0;
+    if (tableIndex < WTF_ARRAY_LENGTH(coreExceptions)) {
+        auto& exception = coreExceptions[tableIndex];
+        description->name = exception.name;
+        description->description = exception.description;
+        description->code = exception.code;
+    } else {
+        description->name = nullptr;
+        description->description = nullptr;
+        description->code = 0;
+    }
 
     return true;
 }
index d34fe1f..d420077 100644 (file)
@@ -32,6 +32,7 @@
 
 namespace WebCore {
 
+// FIXME: We should merge ExceptionBase into DOMException now that ExceptionBase no longer has any other subclasses.
 class DOMException : public ExceptionBase {
 public:
     static Ref<DOMException> create(const ExceptionCodeDescription& description)
index 07fa328..c465ef4 100644 (file)
 
 #include "DOMException.h"
 
-#if ENABLE(INDEXED_DATABASE)
-#include "IDBDatabaseException.h"
-#endif
-
 namespace WebCore {
 
 ExceptionCodeDescription::ExceptionCodeDescription(ExceptionCode ec)
 {
     ASSERT(ec);
-#if ENABLE(INDEXED_DATABASE)
-    if (IDBDatabaseException::initializeDescription(ec, this))
-        return;
-#endif
     if (DOMException::initializeDescription(ec, this))
         return;
     ASSERT_NOT_REACHED();
index d536880..ea5f4b1 100644 (file)
 
 namespace WebCore {
 
-enum ExceptionType {
-    DOMExceptionType,
-#if ENABLE(INDEXED_DATABASE)
-    IDBDatabaseExceptionType,
-#endif
-};
-
+// FIXME: This should be refactored now that there is only one exception type.
 struct ExceptionCodeDescription {
     WEBCORE_EXPORT explicit ExceptionCodeDescription(ExceptionCode);
 
@@ -55,8 +49,6 @@ struct ExceptionCodeDescription {
 
     // |code| is the numeric value of the exception within a particular type.
     int code;
-
-    ExceptionType type;
 };
 
 } // namespace WebCore
index 51fc6cf..92fed55 100644 (file)
@@ -1,3 +1,13 @@
+2017-07-21  Chris Dumez  <cdumez@apple.com>
+
+        Drop IDBDatabaseException class
+        https://bugs.webkit.org/show_bug.cgi?id=174743
+
+        Reviewed by Darin Adler.
+
+        * WebProcess/Databases/IndexedDB/WebIDBConnectionToServer.cpp:
+        (WebKit::WebIDBConnectionToServer::connectionToServerLost):
+
 2017-07-21  Brady Eidson  <beidson@apple.com>
 
         Crash in many WebKit apps marking a connection invalid under Messages::NetworkProcessProxy::canAuthenticateAgainstProtectionSpace.
index 19cfcd5..b272275 100644 (file)
@@ -39,7 +39,6 @@
 #include "WebToDatabaseProcessConnection.h"
 #include <WebCore/IDBConnectionToServer.h>
 #include <WebCore/IDBCursorInfo.h>
-#include <WebCore/IDBDatabaseException.h>
 #include <WebCore/IDBError.h>
 #include <WebCore/IDBIndexInfo.h>
 #include <WebCore/IDBIterateCursorData.h>
@@ -361,7 +360,7 @@ void WebIDBConnectionToServer::didGetAllDatabaseNames(uint64_t callbackID, const
 
 void WebIDBConnectionToServer::connectionToServerLost()
 {
-    m_connectionToServer->connectionToServerLost({ WebCore::IDBDatabaseException::UnknownError, ASCIILiteral("An internal error was encountered in the Indexed Database server") });
+    m_connectionToServer->connectionToServerLost({ WebCore::UnknownError, ASCIILiteral("An internal error was encountered in the Indexed Database server") });
 }
 
 } // namespace WebKit