Attachment #70272 for bug #47389

View Details Raw Unified Return to Bug 47389

| Differences between



2010-10-08  Andrei Popescu  <andreip@google.com>

        Reviewed by NOBODY (OOPS!).

        IndexedDB does not have a quota mechanism.
        https://bugs.webkit.org/show_bug.cgi?id=47389

        * storage/indexeddb/database-quota-expected.txt: Added.
        * storage/indexeddb/database-quota.html: Added.

2010-10-08  Renata Hodovan  <reni@inf.u-szeged.hu>

        Reviewed by Nikolas Zimmermann.



Tests IndexedDB's quota enforcing mechanism.

On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".


indexedDB.open('name', 'description')
PASS 'onsuccess' in result is true
PASS 'onerror' in result is true
PASS 'readyState' in result is true
An event should fire shortly...

Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

db = event.result
db.setVersion('new version')
PASS 'onsuccess' in result is true
PASS 'onerror' in result is true
PASS 'readyState' in result is true
An event should fire shortly...

setVersionSuccess():
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

trans = event.result
PASS trans !== null is true
Deleted all object stores.
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

FAIL db.version should be version b. Was new version.
PASS db.name is "name"
PASS db.objectStores is []
PASS db.objectStores.length is 0
PASS db.objectStores.contains('') is false
db.createObjectStore("test123")
PASS db.objectStores is ['test123']
PASS db.objectStores.length is 1
PASS db.objectStores.contains('') is false
PASS db.objectStores.contains('test456') is false
PASS db.objectStores.contains('test123') is true
trans = db.transaction()
Creating 'data' which contains 64K of data
PASS data.length is 65536
store = trans.objectStore('test123')
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Success event fired:
PASS 'result' in event is true
PASS 'code' in event is false
PASS 'message' in event is false
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

store = event.source
store.add({x: data}, dataAdded)
Error function called: (0) Error writing data to stable storage.
Error event fired:
PASS 'result' in event is false
PASS 'code' in event is true
PASS 'message' in event is true
PASS 'source' in event is true
PASS event.source != null is true
PASS 'onsuccess' in event.target is true
PASS 'onerror' in event.target is true
PASS 'readyState' in event.target is true
PASS event.target.readyState is event.target.DONE

PASS Adding data failed due to quota error. Data added was: 5120 KB
PASS successfullyParsed is true

TEST COMPLETE




<html>
<head>
<link rel="stylesheet" href="../../fast/js/resources/js-test-style.css">
<script src="../../fast/js/resources/js-test-pre.js"></script>
<script src="../../fast/js/resources/js-test-post-function.js"></script>
<script src="resources/shared.js"></script>
</head>
<body>
<p id="description"></p>
<div id="console"></div>
<script>

description("Tests IndexedDB's quota enforcing mechanism.");
if (window.layoutTestController) 
    layoutTestController.waitUntilDone();

function test()
{
    result = evalAndLog("indexedDB.open('name', 'description')");
    verifyResult(result);
    result.onsuccess = openSuccess;
    result.onerror = unexpectedErrorCallback;
}

function openSuccess()
{
    verifySuccessEvent(event);
    window.db = evalAndLog("db = event.result");

    result = evalAndLog("db.setVersion('new version')");
    verifyResult(result);
    result.onsuccess = setVersionSuccess;
    result.onerror = unexpectedErrorCallback;
}

function setVersionSuccess()
{
    debug("setVersionSuccess():");
    verifySuccessEvent(event);
    window.trans = evalAndLog("trans = event.result");
    shouldBeTrue("trans !== null");
    trans.onabort = unexpectedAbortCallback;

    deleteAllObjectStores(db, createNewObjectStore);
}

function createNewObjectStore()
{
    verifySuccessEvent(event);
    shouldBeEqualToString("db.version", "version b");
    shouldBeEqualToString("db.name", "name");
    shouldBe("db.objectStores", "[]");
    shouldBe("db.objectStores.length", "0");
    shouldBe("db.objectStores.contains('')", "false");

    objectStore = evalAndLog('db.createObjectStore("test123")');
    checkObjectStore();
    commitAndContinue();
}

function checkObjectStore()
{
    shouldBe("db.objectStores", "['test123']");
    shouldBe("db.objectStores.length", "1");
    shouldBe("db.objectStores.contains('')", "false");
    shouldBe("db.objectStores.contains('test456')", "false");
    shouldBe("db.objectStores.contains('test123')", "true");
}

function commitAndContinue()
{
    window.setTimeout(checkQuotaEnforcing, 0);
}

function checkQuotaEnforcing()
{
    var trans = evalAndLog("trans = db.transaction()");
    trans.onabort = testComplete;
    trans.oncomplete = unexpectedCompleteCallback;
    debug("Creating 'data' which contains 64K of data");
    window.data = "X";
    for (var i = 0; i < 16; i++)
        data += data;
    shouldBe("data.length", "65536");
    window.dataAdded = 0;
    window.store = evalAndLog("store = trans.objectStore('test123')");
    addData();
}

function addData()
{
    if (dataAdded < 5 * 1024 * 1024) {
        if (dataAdded > 0) {
            verifySuccessEvent(event);
            store = evalAndLog("store = event.source");
        }
    } else {
        testFailed("added more than quota");
        done();
        return;
    }
    dataAdded += 65536;
    result = evalAndLog("store.add({x: data}, dataAdded)");
    result.onsuccess = addData;
    result.onerror = logError;
}

function logError()
{
    debug("Error function called: (" + event.code + ") " + event.message);
    verifyErrorEvent(event);
}

function testComplete()
{
    testPassed("Adding data failed due to quota error. Data added was: " + dataAdded / 1024 + " KB");
    done();
}

test();

var successfullyParsed = true;

</script>
</body>
</html>



2010-10-08  Andrei Popescu  <andreip@google.com>

        Reviewed by NOBODY (OOPS!).

        IndexedDB does not have a quota mechanism.
        https://bugs.webkit.org/show_bug.cgi?id=47389

        Test: storage/indexeddb/database-quota.html

        Add a simple mechanism for enforcing a maximum size
        for each origin using IndexedDB. Note that this depends
        on having one SQLite database file per origin, which is
        addressed in a separate patch.

        * page/GroupSettings.cpp:
        (WebCore::GroupSettings::GroupSettings):
        (WebCore::GroupSettings::setIndexedDBQuotaBytes):
        * page/GroupSettings.h:
        (WebCore::GroupSettings::indexedDBQuotaBytes):
        * storage/IDBDatabaseBackendImpl.cpp:
        (WebCore::IDBDatabaseBackendImpl::createObjectStore):
        (WebCore::IDBDatabaseBackendImpl::createObjectStoreInternal):
        (WebCore::IDBDatabaseBackendImpl::removeObjectStore):
        (WebCore::IDBDatabaseBackendImpl::setVersionInternal):
        * storage/IDBFactory.cpp:
        (WebCore::IDBFactory::open):
        * storage/IDBFactoryBackendImpl.cpp:
        (WebCore::openSQLiteDatabase):
        (WebCore::IDBFactoryBackendImpl::open):
        * storage/IDBFactoryBackendImpl.h:
        * storage/IDBFactoryBackendInterface.h:
        * storage/IDBObjectStoreBackendImpl.cpp:
        (WebCore::putObjectStoreData):
        (WebCore::putIndexData):
        (WebCore::IDBObjectStoreBackendImpl::put):
        (WebCore::IDBObjectStoreBackendImpl::putInternal):
        (WebCore::IDBObjectStoreBackendImpl::createIndexInternal):
        * storage/IDBObjectStoreBackendImpl.h:

2010-10-08  Benjamin Poulain  <benjamin.poulain@nokia.com>

        Reviewed by Andreas Kling.

Lines 30-35 namespace WebCore { a/WebCore/page/GroupSettings.cpp_sec1
- a/WebCore/page/GroupSettings.cpp +7 lines
30		30
31	GroupSettings::GroupSettings()	31	GroupSettings::GroupSettings()
32	: m_localStorageQuotaBytes(5 * 1024 * 1024) // Suggested by the HTML5 spec.	32	: m_localStorageQuotaBytes(5 * 1024 * 1024) // Suggested by the HTML5 spec.
		33	, m_indexedDBQuotaBytes(5 * 1024 * 1024)
33	{	34	{
34	}	35	}
35		36
Lines 43-46 void GroupSettings::setIndexedDBDatabasePath(const String& path) a/WebCore/page/GroupSettings.cpp_sec2
43	m_indexedDBDatabasePath = path;	44	m_indexedDBDatabasePath = path;
44	}	45	}
45		46
		47	void GroupSettings::setIndexedDBQuotaBytes(int64_t quota)
		48	{
		49	m_indexedDBQuotaBytes = quota;
		50	}
		51
		52
46	} // namespace WebCore	53	} // namespace WebCore

Lines 43-48 public: a/WebCore/page/GroupSettings.h_sec1
- a/WebCore/page/GroupSettings.h +4 lines
43	void setLocalStorageQuotaBytes(unsigned);	43	void setLocalStorageQuotaBytes(unsigned);
44	unsigned localStorageQuotaBytes() const { return m_localStorageQuotaBytes; }	44	unsigned localStorageQuotaBytes() const { return m_localStorageQuotaBytes; }
45		45
		46	void setIndexedDBQuotaBytes(int64_t);
		47	int64_t indexedDBQuotaBytes() const { return m_indexedDBQuotaBytes; }
		48
46	void setIndexedDBDatabasePath(const String&);	49	void setIndexedDBDatabasePath(const String&);
47	const String& indexedDBDatabasePath() const { return m_indexedDBDatabasePath; }	50	const String& indexedDBDatabasePath() const { return m_indexedDBDatabasePath; }
48		51
Lines 51-56 private: a/WebCore/page/GroupSettings.h_sec2
51		54
52	unsigned m_localStorageQuotaBytes;	55	unsigned m_localStorageQuotaBytes;
53	String m_indexedDBDatabasePath;	56	String m_indexedDBDatabasePath;
		57	int64_t m_indexedDBQuotaBytes;
54	};	58	};
55		59
56	} // namespace WebCore	60	} // namespace WebCore



    return objectStoreNames.release();
}

PassRefPtr<IDBObjectStoreBackendInterface>  IDBDatabaseBackendImpl::createObjectStore(const String& name, const String& keyPath, bool autoIncrement, IDBTransactionBackendInterface* transactionPtr)
{
    if (m_objectStores.contains(name)) {
        // FIXME: Throw CONSTRAINT_ERR in this case.

    ASSERT(objectStore->name() == name);

    RefPtr<IDBDatabaseBackendImpl> database = this;
    RefPtr<IDBTransactionBackendInterface> transaction = transactionPtr;
    if (!transaction->scheduleTask(createCallbackTask(&IDBDatabaseBackendImpl::createObjectStoreInternal, database, objectStore, transaction),
                                   createCallbackTask(&IDBDatabaseBackendImpl::removeObjectStoreFromMap, database, objectStore))) {
        return 0;
    }

void IDBDatabaseBackendImpl::createObjectStoreInternal(ScriptExecutionContext*, PassRefPtr<IDBDatabaseBackendImpl> database, PassRefPtr<IDBObjectStoreBackendImpl> objectStore,  PassRefPtr<IDBTransactionBackendInterface> transaction)
{
    SQLiteStatement insert(database->sqliteDatabase(), "INSERT INTO ObjectStores (name, keyPath, doAutoIncrement) VALUES (?, ?, ?)");
    if (insert.prepare() != SQLResultOk) {
        transaction->abort();
        return;
    }
    insert.bindText(1, objectStore->name());
    insert.bindText(2, objectStore->keyPath());
    insert.bindInt(3, static_cast<int>(objectStore->autoIncrement()));
    if (insert.step() != SQLResultDone) {
        transaction->abort();
        return;
    }
    int64_t id = database->sqliteDatabase().lastInsertRowID();
    objectStore->setId(id);
    transaction->didCompleteTaskEvents();

    ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.
}

void IDBDatabaseBackendImpl::removeObjectStore(const String& name, IDBTransactionBackendInterface* transactionPtr)
{
    RefPtr<IDBObjectStoreBackendImpl> objectStore = m_objectStores.get(name);
    if (!objectStore) {

        return;
    }
    RefPtr<IDBDatabaseBackendImpl> database = this;
    RefPtr<IDBTransactionBackendInterface> transaction = transactionPtr;
    if (!transaction->scheduleTask(createCallbackTask(&IDBDatabaseBackendImpl::removeObjectStoreInternal, database, objectStore, transaction),
                                   createCallbackTask(&IDBDatabaseBackendImpl::addObjectStoreToMap, database, objectStore))) {
        // FIXME: Raise NOT_ALLOWED_ERR if the above fails.
        return;

void IDBDatabaseBackendImpl::setVersionInternal(ScriptExecutionContext*, PassRefPtr<IDBDatabaseBackendImpl> database, const String& version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBTransactionBackendInterface> transaction)
{
    database->m_version = version;
    if (!setMetaData(database->m_sqliteDatabase.get(), database->m_name, database->m_description, database->m_version)) {
        // FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
        callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
        transaction->abort();
        return;
    }
    callbacks->onSuccess(transaction);
}




        return 0;

    RefPtr<IDBRequest> request = IDBRequest::create(document, IDBAny::create(this), 0);
    GroupSettings* groupSettings = document->page()->group().groupSettings();
    m_factoryBackend->open(name, description, request, document->securityOrigin(), document->frame(), groupSettings->indexedDBDatabasePath(), groupSettings->indexedDBQuotaBytes());
    return request;
}




{
}

static PassOwnPtr<SQLiteDatabase> openSQLiteDatabase(SecurityOrigin* securityOrigin, String name, const String& pathBase, int64_t maximumSize)
{
    String path = ":memory:";
    if (!pathBase.isEmpty()) {

        return 0;
    }

    sqliteDatabase->setMaximumSize(maximumSize);
    return sqliteDatabase.release();
}


    return true;
}

void IDBFactoryBackendImpl::open(const String& name, const String& description, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> securityOrigin, Frame*, const String& dataDir, int64_t maximumSize)
{
    IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(name);
    if (it != m_databaseBackendMap.end()) {


    // FIXME: Everything from now on should be done on another thread.

    OwnPtr<SQLiteDatabase> sqliteDatabase = openSQLiteDatabase(securityOrigin.get(), name, dataDir, maximumSize);
    if (!sqliteDatabase || !createTables(sqliteDatabase.get())) {
        callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Internal error."));
        return;

Lines 49-55 public: a/WebCore/storage/IDBFactoryBackendImpl.h_sec1
- a/WebCore/storage/IDBFactoryBackendImpl.h -1 / +1 lines
49	}	49	}
50	virtual ~IDBFactoryBackendImpl();	50	virtual ~IDBFactoryBackendImpl();
51		51
52	virtual void open(const String& name, const String& description, PassRefPtr<IDBCallbacks>, PassRefPtr<SecurityOrigin>, Frame*, const String& dataDir);	52	virtual void open(const String& name, const String& description, PassRefPtr<IDBCallbacks>, PassRefPtr<SecurityOrigin>, Frame*, const String& dataDir, int64_t maximumSize);
53		53
54	static String databaseFileName(const String& name, SecurityOrigin*);	54	static String databaseFileName(const String& name, SecurityOrigin*);
55		55

Lines 51-57 public: a/WebCore/storage/IDBFactoryBackendInterface.h_sec1
- a/WebCore/storage/IDBFactoryBackendInterface.h -1 / +1 lines
51	static PassRefPtr<IDBFactoryBackendInterface> create();	51	static PassRefPtr<IDBFactoryBackendInterface> create();
52	virtual ~IDBFactoryBackendInterface() { }	52	virtual ~IDBFactoryBackendInterface() { }
53		53
54	virtual void open(const String& name, const String& description, PassRefPtr<IDBCallbacks>, PassRefPtr<SecurityOrigin>, Frame*, const String& dataDir) = 0;	54	virtual void open(const String& name, const String& description, PassRefPtr<IDBCallbacks>, PassRefPtr<SecurityOrigin>, Frame*, const String& dataDir, int64_t maximumSize) = 0;
55	};	55	};
56		56
57	} // namespace WebCore	57	} // namespace WebCore



    return keys[0].release();
}

static bool putObjectStoreData(SQLiteDatabase& db, IDBKey* key, SerializedScriptValue* value, int64_t objectStoreId, int64_t* dataRowId)
{
    String sql = *dataRowId != -1 ? "UPDATE ObjectStoreData SET keyString = ?, keyDate = ?, keyNumber = ?, value = ? WHERE id = ?"
                                  : "INSERT INTO ObjectStoreData (keyString, keyDate, keyNumber, value, objectStoreId) VALUES (?, ?, ?, ?, ?)";
    SQLiteStatement query(db, sql);
    if (query.prepare() != SQLResultOk)
        return false;
    key->bindWithNulls(query, 1);
    query.bindText(4, value->toWireString());
    if (*dataRowId != -1)

    else
        query.bindInt64(5, objectStoreId);

    if (query.step() != SQLResultDone)
        return false;

    if (*dataRowId == -1)
        *dataRowId = db.lastInsertRowID();

    return true;
}

static int putIndexData(SQLiteDatabase& db, IDBKey* key, int64_t indexId, int64_t objectStoreDataId)
{
    SQLiteStatement deleteQuery(db, "DELETE FROM IndexData WHERE objectStoreDataId = ?");
    if (deleteQuery.prepare() != SQLResultOk)
        return false;
    deleteQuery.bindInt64(1, objectStoreDataId);
    if (deleteQuery.step() != SQLResultDone)
        return false;

    SQLiteStatement putQuery(db, "INSERT INTO IndexData (keyString, keyDate, keyNumber, indexId, objectStoreDataId) VALUES (?, ?, ?, ?, ?)");
    if (putQuery.prepare() != SQLResultOk)
        return false;
    key->bindWithNulls(putQuery, 1);
    putQuery.bindInt64(4, indexId);
    putQuery.bindInt64(5, objectStoreDataId);

    return putQuery.step() == SQLResultDone;
    ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?
}

void IDBObjectStoreBackendImpl::put(PassRefPtr<SerializedScriptValue> prpValue, PassRefPtr<IDBKey> prpKey, bool addOnly, PassRefPtr<IDBCallbacks> prpCallbacks, IDBTransactionBackendInterface* transactionPtr)
{
    RefPtr<IDBObjectStoreBackendImpl> objectStore = this;
    RefPtr<SerializedScriptValue> value = prpValue;
    RefPtr<IDBKey> key = prpKey;
    RefPtr<IDBCallbacks> callbacks = prpCallbacks;
    RefPtr<IDBTransactionBackendInterface> transaction = transactionPtr;
    if (!transaction->scheduleTask(createCallbackTask(&IDBObjectStoreBackendImpl::putInternal, objectStore, value, key, addOnly, callbacks, transaction)))
        callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::NOT_ALLOWED_ERR, "put must be called in the context of a transaction."));
}

void IDBObjectStoreBackendImpl::putInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<SerializedScriptValue> prpValue, PassRefPtr<IDBKey> prpKey, bool addOnly, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBTransactionBackendInterface> transaction)
{
    RefPtr<SerializedScriptValue> value = prpValue;
    RefPtr<IDBKey> key = prpKey;

        return;
    }

    // Before this point, don't do any mutation.  After this point, rollback the transaction in case of error.

    int64_t dataRowId = isExistingValue ? getQuery.getColumnInt(0) : -1;
    if (!putObjectStoreData(objectStore->sqliteDatabase(), key.get(), value.get(), objectStore->id(), &dataRowId)) {
        // FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
        callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
        transaction->abort();
        return;
    }

    int i = 0;
    for (IndexMap::iterator it = objectStore->m_indexes.begin(); it != objectStore->m_indexes.end(); ++it, ++i) {
        if (!putIndexData(objectStore->sqliteDatabase(), indexKeys[i].get(), it->second->id(), dataRowId)) {
            // FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
            callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
            transaction->abort();
            return;
        }
    }

    callbacks->onSuccess(key.get());
}

void IDBObjectStoreBackendImpl::createIndexInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<IDBIndexBackendImpl> index, PassRefPtr<IDBTransactionBackendInterface> transaction)
{
    SQLiteStatement insert(objectStore->sqliteDatabase(), "INSERT INTO Indexes (objectStoreId, name, keyPath, isUnique) VALUES (?, ?, ?, ?)");
    if (!insert.prepare()) {
        transaction->abort();
        return;
    }
    insert.bindInt64(1, objectStore->m_id);
    insert.bindText(2, index->name());
    insert.bindText(3, index->keyPath());
    insert.bindInt(4, static_cast<int>(index->unique()));
    if (!insert.step()) {
        transaction->abort();
        return;
    }
    int64_t id = objectStore->sqliteDatabase().lastInsertRowID();
    index->setId(id);
    transaction->didCompleteTaskEvents();

Lines 83-89 private: a/WebCore/storage/IDBObjectStoreBackendImpl.h_sec1
- a/WebCore/storage/IDBObjectStoreBackendImpl.h -1 / +1 lines
83	SQLiteDatabase& sqliteDatabase() const;	83	SQLiteDatabase& sqliteDatabase() const;
84		84
85	static void getInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<IDBKey> key, PassRefPtr<IDBCallbacks>);	85	static void getInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<IDBKey> key, PassRefPtr<IDBCallbacks>);
86	static void putInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<SerializedScriptValue> value, PassRefPtr<IDBKey> key, bool addOnly, PassRefPtr<IDBCallbacks>);	86	static void putInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<SerializedScriptValue> value, PassRefPtr<IDBKey> key, bool addOnly, PassRefPtr<IDBCallbacks>, PassRefPtr<IDBTransactionBackendInterface> transaction);
87	static void removeInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<IDBKey> key, PassRefPtr<IDBCallbacks>);	87	static void removeInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<IDBKey> key, PassRefPtr<IDBCallbacks>);
88	static void createIndexInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<IDBIndexBackendImpl>, PassRefPtr<IDBTransactionBackendInterface>);	88	static void createIndexInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<IDBIndexBackendImpl>, PassRefPtr<IDBTransactionBackendInterface>);
89	static void removeIndexInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<IDBIndexBackendImpl>, PassRefPtr<IDBTransactionBackendInterface>);	89	static void removeIndexInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl>, PassRefPtr<IDBIndexBackendImpl>, PassRefPtr<IDBTransactionBackendInterface>);



2010-10-08  Andrei Popescu  <andreip@google.com>

        Reviewed by NOBODY (OOPS!).

        IndexedDB does not have a quota mechanism.
        https://bugs.webkit.org/show_bug.cgi?id=47389

        * public/WebIDBFactory.h:
        (WebKit::WebIDBFactory::open):
        * src/IDBFactoryBackendProxy.cpp:
        (WebCore::IDBFactoryBackendProxy::open):
        * src/IDBFactoryBackendProxy.h:
        * src/WebIDBFactoryImpl.cpp:
        (WebKit::WebIDBFactoryImpl::open):
        * src/WebIDBFactoryImpl.h:

2010-10-07  Zhenyao Mo  <zmo@google.com>

        Unreviewed, roll chromium to r61902.

Lines 52-57 public: a/WebKit/chromium/public/WebIDBFactory.h_sec1
- a/WebKit/chromium/public/WebIDBFactory.h +2 lines
52	virtual ~WebIDBFactory() { }	52	virtual ~WebIDBFactory() { }
53		53
54	// The WebKit implementation of open ignores the WebFrame* parameter.	54	// The WebKit implementation of open ignores the WebFrame* parameter.
		55	virtual void open(const WebString& name, const WebString& description, WebIDBCallbacks* callbacks, const WebSecurityOrigin& origin, WebFrame* webFrame, const WebString& dataDir, unsigned long long maximumSize) { WEBKIT_ASSERT_NOT_REACHED(); }
		56	// FIXME: Remove once we update Chromium side.
55	virtual void open(const WebString& name, const WebString& description, WebIDBCallbacks* callbacks, const WebSecurityOrigin& origin, WebFrame* webFrame, const WebString& dataDir) { WEBKIT_ASSERT_NOT_REACHED(); }	57	virtual void open(const WebString& name, const WebString& description, WebIDBCallbacks* callbacks, const WebSecurityOrigin& origin, WebFrame* webFrame, const WebString& dataDir) { WEBKIT_ASSERT_NOT_REACHED(); }
56		58
57	// The file name that would be used for persisting a given indexed database on the file system.	59	// The file name that would be used for persisting a given indexed database on the file system.



{
}

void IDBFactoryBackendProxy::open(const String& name, const String& description, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> origin, Frame* frame, const String& dataDir, int64_t maximumSize)
{
    WebKit::WebFrame* webFrame = WebKit::WebFrameImpl::fromFrame(frame);
    m_webIDBFactory->open(name, description, new WebIDBCallbacksImpl(callbacks), origin, webFrame, dataDir, maximumSize);
}

} // namespace WebCore

Lines 45-51 public: a/WebKit/chromium/src/IDBFactoryBackendProxy.h_sec1
- a/WebKit/chromium/src/IDBFactoryBackendProxy.h -1 / +1 lines
45	virtual ~IDBFactoryBackendProxy();	45	virtual ~IDBFactoryBackendProxy();
46		46
47	PassRefPtr<DOMStringList> databases(void) const;	47	PassRefPtr<DOMStringList> databases(void) const;
48	virtual void open(const String& name, const String& description, PassRefPtr<IDBCallbacks>, PassRefPtr<SecurityOrigin>, Frame*, const String& dataDir);	48	virtual void open(const String& name, const String& description, PassRefPtr<IDBCallbacks>, PassRefPtr<SecurityOrigin>, Frame*, const String& dataDir, int64_t maximumSize);
49		49
50	private:	50	private:
51	IDBFactoryBackendProxy();	51	IDBFactoryBackendProxy();



{
}

void WebIDBFactoryImpl::open(const WebString& name, const WebString& description, WebIDBCallbacks* callbacks, const WebSecurityOrigin& origin, WebFrame*, const WebString& dataDir, unsigned long long maximumSize)
{
    m_idbFactoryBackend->open(name, description, IDBCallbacksProxy::create(callbacks), origin, 0, dataDir, maximumSize);
}

} // namespace WebKit

Lines 42-48 public: a/WebKit/chromium/src/WebIDBFactoryImpl.h_sec1
- a/WebKit/chromium/src/WebIDBFactoryImpl.h -1 / +1 lines
42	WebIDBFactoryImpl();	42	WebIDBFactoryImpl();
43	virtual ~WebIDBFactoryImpl();	43	virtual ~WebIDBFactoryImpl();
44		44
45	virtual void open(const WebString& name, const WebString& description, WebIDBCallbacks, const WebSecurityOrigin&, WebFrame, const WebString& dataDir);	45	virtual void open(const WebString& name, const WebString& description, WebIDBCallbacks, const WebSecurityOrigin&, WebFrame, const WebString& dataDir, unsigned long long maximumSize);
46		46
47	private:	47	private:
48	WTF::RefPtr<WebCore::IDBFactoryBackendInterface> m_idbFactoryBackend;	48	WTF::RefPtr<WebCore::IDBFactoryBackendInterface> m_idbFactoryBackend;

Return to Bug 47389

Lines 127-133 PassRefPtr<DOMStringList> IDBDatabaseBackendImpl::objectStores() const a/WebCore/storage/IDBDatabaseBackendImpl.cpp_sec1
- a/WebCore/storage/IDBDatabaseBackendImpl.cpp -11 / +20 lines
127	return objectStoreNames.release();	127	return objectStoreNames.release();
128	}	128	}
129		129
130	PassRefPtr<IDBObjectStoreBackendInterface> IDBDatabaseBackendImpl::createObjectStore(const String& name, const String& keyPath, bool autoIncrement, IDBTransactionBackendInterface* transaction)	130	PassRefPtr<IDBObjectStoreBackendInterface> IDBDatabaseBackendImpl::createObjectStore(const String& name, const String& keyPath, bool autoIncrement, IDBTransactionBackendInterface* transactionPtr)
131	{	131	{
132	if (m_objectStores.contains(name)) {	132	if (m_objectStores.contains(name)) {
133	// FIXME: Throw CONSTRAINT_ERR in this case.	133	// FIXME: Throw CONSTRAINT_ERR in this case.
Lines 138-145 PassRefPtr<IDBObjectStoreBackendInterface> IDBDatabaseBackendImpl::createObject a/WebCore/storage/IDBDatabaseBackendImpl.cpp_sec2
138	ASSERT(objectStore->name() == name);	138	ASSERT(objectStore->name() == name);
139		139
140	RefPtr<IDBDatabaseBackendImpl> database = this;	140	RefPtr<IDBDatabaseBackendImpl> database = this;
141	RefPtr<IDBTransactionBackendInterface> transactionPtr = transaction;	141	RefPtr<IDBTransactionBackendInterface> transaction = transactionPtr;
142	if (!transaction->scheduleTask(createCallbackTask(&IDBDatabaseBackendImpl::createObjectStoreInternal, database, objectStore, transactionPtr),	142	if (!transaction->scheduleTask(createCallbackTask(&IDBDatabaseBackendImpl::createObjectStoreInternal, database, objectStore, transaction),
143	createCallbackTask(&IDBDatabaseBackendImpl::removeObjectStoreFromMap, database, objectStore))) {	143	createCallbackTask(&IDBDatabaseBackendImpl::removeObjectStoreFromMap, database, objectStore))) {
144	return 0;	144	return 0;
145	}	145	}
Lines 151-163 PassRefPtr<IDBObjectStoreBackendInterface> IDBDatabaseBackendImpl::createObject a/WebCore/storage/IDBDatabaseBackendImpl.cpp_sec3
151	void IDBDatabaseBackendImpl::createObjectStoreInternal(ScriptExecutionContext*, PassRefPtr<IDBDatabaseBackendImpl> database, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<IDBTransactionBackendInterface> transaction)	151	void IDBDatabaseBackendImpl::createObjectStoreInternal(ScriptExecutionContext*, PassRefPtr<IDBDatabaseBackendImpl> database, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<IDBTransactionBackendInterface> transaction)
152	{	152	{
153	SQLiteStatement insert(database->sqliteDatabase(), "INSERT INTO ObjectStores (name, keyPath, doAutoIncrement) VALUES (?, ?, ?)");	153	SQLiteStatement insert(database->sqliteDatabase(), "INSERT INTO ObjectStores (name, keyPath, doAutoIncrement) VALUES (?, ?, ?)");
154	bool ok = insert.prepare() == SQLResultOk;	154	if (insert.prepare() != SQLResultOk) {
155	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.	155	transaction->abort();
		156	return;
		157	}
156	insert.bindText(1, objectStore->name());	158	insert.bindText(1, objectStore->name());
157	insert.bindText(2, objectStore->keyPath());	159	insert.bindText(2, objectStore->keyPath());
158	insert.bindInt(3, static_cast<int>(objectStore->autoIncrement()));	160	insert.bindInt(3, static_cast<int>(objectStore->autoIncrement()));
159	ok = insert.step() == SQLResultDone;	161	if (insert.step() != SQLResultDone) {
160	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.	162	transaction->abort();
		163	return;
		164	}
161	int64_t id = database->sqliteDatabase().lastInsertRowID();	165	int64_t id = database->sqliteDatabase().lastInsertRowID();
162	objectStore->setId(id);	166	objectStore->setId(id);
163	transaction->didCompleteTaskEvents();	167	transaction->didCompleteTaskEvents();
Lines 181-187 static void doDelete(SQLiteDatabase& db, const char* sql, int64_t id) a/WebCore/storage/IDBDatabaseBackendImpl.cpp_sec4
181	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.	185	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.
182	}	186	}
183		187
184	void IDBDatabaseBackendImpl::removeObjectStore(const String& name, IDBTransactionBackendInterface* transaction)	188	void IDBDatabaseBackendImpl::removeObjectStore(const String& name, IDBTransactionBackendInterface* transactionPtr)
185	{	189	{
186	RefPtr<IDBObjectStoreBackendImpl> objectStore = m_objectStores.get(name);	190	RefPtr<IDBObjectStoreBackendImpl> objectStore = m_objectStores.get(name);
187	if (!objectStore) {	191	if (!objectStore) {
Lines 189-196 void IDBDatabaseBackendImpl::removeObjectStore(const String& name, IDBTransactio a/WebCore/storage/IDBDatabaseBackendImpl.cpp_sec5
189	return;	193	return;
190	}	194	}
191	RefPtr<IDBDatabaseBackendImpl> database = this;	195	RefPtr<IDBDatabaseBackendImpl> database = this;
192	RefPtr<IDBTransactionBackendInterface> transactionPtr = transaction;	196	RefPtr<IDBTransactionBackendInterface> transaction = transactionPtr;
193	if (!transaction->scheduleTask(createCallbackTask(&IDBDatabaseBackendImpl::removeObjectStoreInternal, database, objectStore, transactionPtr),	197	if (!transaction->scheduleTask(createCallbackTask(&IDBDatabaseBackendImpl::removeObjectStoreInternal, database, objectStore, transaction),
194	createCallbackTask(&IDBDatabaseBackendImpl::addObjectStoreToMap, database, objectStore))) {	198	createCallbackTask(&IDBDatabaseBackendImpl::addObjectStoreToMap, database, objectStore))) {
195	// FIXME: Raise NOT_ALLOWED_ERR if the above fails.	199	// FIXME: Raise NOT_ALLOWED_ERR if the above fails.
196	return;	200	return;
Lines 223-229 void IDBDatabaseBackendImpl::setVersion(const String& version, PassRefPtr<IDBCal a/WebCore/storage/IDBDatabaseBackendImpl.cpp_sec6
223	void IDBDatabaseBackendImpl::setVersionInternal(ScriptExecutionContext*, PassRefPtr<IDBDatabaseBackendImpl> database, const String& version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBTransactionBackendInterface> transaction)	227	void IDBDatabaseBackendImpl::setVersionInternal(ScriptExecutionContext*, PassRefPtr<IDBDatabaseBackendImpl> database, const String& version, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBTransactionBackendInterface> transaction)
224	{	228	{
225	database->m_version = version;	229	database->m_version = version;
226	setMetaData(database->m_sqliteDatabase.get(), database->m_name, database->m_description, database->m_version);	230	if (!setMetaData(database->m_sqliteDatabase.get(), database->m_name, database->m_description, database->m_version)) {
		231	// FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
		232	callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
		233	transaction->abort();
		234	return;
		235	}
227	callbacks->onSuccess(transaction);	236	callbacks->onSuccess(transaction);
228	}	237	}
229		238

Lines 131-143 static PassRefPtr<IDBKey> fetchKeyFromKeyPath(SerializedScriptValue* value, cons a/WebCore/storage/IDBObjectStoreBackendImpl.cpp_sec1
- a/WebCore/storage/IDBObjectStoreBackendImpl.cpp -25 / +42 lines
131	return keys[0].release();	131	return keys[0].release();
132	}	132	}
133		133
134	static void putObjectStoreData(SQLiteDatabase& db, IDBKey* key, SerializedScriptValue* value, int64_t objectStoreId, int64_t* dataRowId)	134	static bool putObjectStoreData(SQLiteDatabase& db, IDBKey* key, SerializedScriptValue* value, int64_t objectStoreId, int64_t* dataRowId)
135	{	135	{
136	String sql = *dataRowId != -1 ? "UPDATE ObjectStoreData SET keyString = ?, keyDate = ?, keyNumber = ?, value = ? WHERE id = ?"	136	String sql = *dataRowId != -1 ? "UPDATE ObjectStoreData SET keyString = ?, keyDate = ?, keyNumber = ?, value = ? WHERE id = ?"
137	: "INSERT INTO ObjectStoreData (keyString, keyDate, keyNumber, value, objectStoreId) VALUES (?, ?, ?, ?, ?)";	137	: "INSERT INTO ObjectStoreData (keyString, keyDate, keyNumber, value, objectStoreId) VALUES (?, ?, ?, ?, ?)";
138	SQLiteStatement query(db, sql);	138	SQLiteStatement query(db, sql);
139	bool ok = query.prepare() == SQLResultOk;	139	if (query.prepare() != SQLResultOk)
140	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?	140	return false;
141	key->bindWithNulls(query, 1);	141	key->bindWithNulls(query, 1);
142	query.bindText(4, value->toWireString());	142	query.bindText(4, value->toWireString());
143	if (*dataRowId != -1)	143	if (*dataRowId != -1)
Lines 145-188 static void putObjectStoreData(SQLiteDatabase& db, IDBKey* key, SerializedScript a/WebCore/storage/IDBObjectStoreBackendImpl.cpp_sec2
145	else	145	else
146	query.bindInt64(5, objectStoreId);	146	query.bindInt64(5, objectStoreId);
147		147
148	ok = query.step() == SQLResultDone;	148	if (query.step() != SQLResultDone)
149	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?	149	return false;
150		150
151	if (*dataRowId == -1)	151	if (*dataRowId == -1)
152	*dataRowId = db.lastInsertRowID();	152	*dataRowId = db.lastInsertRowID();
		153
		154	return true;
153	}	155	}
154		156
155	static void putIndexData(SQLiteDatabase& db, IDBKey* key, int64_t indexId, int64_t objectStoreDataId)	157	static int putIndexData(SQLiteDatabase& db, IDBKey* key, int64_t indexId, int64_t objectStoreDataId)
156	{	158	{
157	SQLiteStatement deleteQuery(db, "DELETE FROM IndexData WHERE objectStoreDataId = ?");	159	SQLiteStatement deleteQuery(db, "DELETE FROM IndexData WHERE objectStoreDataId = ?");
158	bool ok = deleteQuery.prepare() == SQLResultOk;	160	if (deleteQuery.prepare() != SQLResultOk)
159	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.	161	return false;
160	deleteQuery.bindInt64(1, objectStoreDataId);	162	deleteQuery.bindInt64(1, objectStoreDataId);
161	ok = deleteQuery.step() == SQLResultDone;	163	if (deleteQuery.step() != SQLResultDone)
162	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.	164	return false;
163		165
164	SQLiteStatement putQuery(db, "INSERT INTO IndexData (keyString, keyDate, keyNumber, indexId, objectStoreDataId) VALUES (?, ?, ?, ?, ?)");	166	SQLiteStatement putQuery(db, "INSERT INTO IndexData (keyString, keyDate, keyNumber, indexId, objectStoreDataId) VALUES (?, ?, ?, ?, ?)");
165	ok = putQuery.prepare() == SQLResultOk;	167	if (putQuery.prepare() != SQLResultOk)
166	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?	168	return false;
167	key->bindWithNulls(putQuery, 1);	169	key->bindWithNulls(putQuery, 1);
168	putQuery.bindInt64(4, indexId);	170	putQuery.bindInt64(4, indexId);
169	putQuery.bindInt64(5, objectStoreDataId);	171	putQuery.bindInt64(5, objectStoreDataId);
170		172
171	ok = putQuery.step() == SQLResultDone;	173	return putQuery.step() == SQLResultDone;
172	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling?
173	}	174	}
174		175
175	void IDBObjectStoreBackendImpl::put(PassRefPtr<SerializedScriptValue> prpValue, PassRefPtr<IDBKey> prpKey, bool addOnly, PassRefPtr<IDBCallbacks> prpCallbacks, IDBTransactionBackendInterface* transaction)	176	void IDBObjectStoreBackendImpl::put(PassRefPtr<SerializedScriptValue> prpValue, PassRefPtr<IDBKey> prpKey, bool addOnly, PassRefPtr<IDBCallbacks> prpCallbacks, IDBTransactionBackendInterface* transactionPtr)
176	{	177	{
177	RefPtr<IDBObjectStoreBackendImpl> objectStore = this;	178	RefPtr<IDBObjectStoreBackendImpl> objectStore = this;
178	RefPtr<SerializedScriptValue> value = prpValue;	179	RefPtr<SerializedScriptValue> value = prpValue;
179	RefPtr<IDBKey> key = prpKey;	180	RefPtr<IDBKey> key = prpKey;
180	RefPtr<IDBCallbacks> callbacks = prpCallbacks;	181	RefPtr<IDBCallbacks> callbacks = prpCallbacks;
181	if (!transaction->scheduleTask(createCallbackTask(&IDBObjectStoreBackendImpl::putInternal, objectStore, value, key, addOnly, callbacks)))	182	RefPtr<IDBTransactionBackendInterface> transaction = transactionPtr;
		183	if (!transaction->scheduleTask(createCallbackTask(&IDBObjectStoreBackendImpl::putInternal, objectStore, value, key, addOnly, callbacks, transaction)))
182	callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::NOT_ALLOWED_ERR, "put must be called in the context of a transaction."));	184	callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::NOT_ALLOWED_ERR, "put must be called in the context of a transaction."));
183	}	185	}
184		186
185	void IDBObjectStoreBackendImpl::putInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<SerializedScriptValue> prpValue, PassRefPtr<IDBKey> prpKey, bool addOnly, PassRefPtr<IDBCallbacks> callbacks)	187	void IDBObjectStoreBackendImpl::putInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<SerializedScriptValue> prpValue, PassRefPtr<IDBKey> prpKey, bool addOnly, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<IDBTransactionBackendInterface> transaction)
186	{	188	{
187	RefPtr<SerializedScriptValue> value = prpValue;	189	RefPtr<SerializedScriptValue> value = prpValue;
188	RefPtr<IDBKey> key = prpKey;	190	RefPtr<IDBKey> key = prpKey;
Lines 227-240 void IDBObjectStoreBackendImpl::putInternal(ScriptExecutionContext*, PassRefPtr< a/WebCore/storage/IDBObjectStoreBackendImpl.cpp_sec3
227	return;	229	return;
228	}	230	}
229		231
230	// Before this point, don't do any mutation. After this point, don't error out.	232	// Before this point, don't do any mutation. After this point, rollback the transaction in case of error.
231		233
232	int64_t dataRowId = isExistingValue ? getQuery.getColumnInt(0) : -1;	234	int64_t dataRowId = isExistingValue ? getQuery.getColumnInt(0) : -1;
233	putObjectStoreData(objectStore->sqliteDatabase(), key.get(), value.get(), objectStore->id(), &dataRowId);	235	if (!putObjectStoreData(objectStore->sqliteDatabase(), key.get(), value.get(), objectStore->id(), &dataRowId)) {
		236	// FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
		237	callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
		238	transaction->abort();
		239	return;
		240	}
234		241
235	int i = 0;	242	int i = 0;
236	for (IndexMap::iterator it = objectStore->m_indexes.begin(); it != objectStore->m_indexes.end(); ++it, ++i)	243	for (IndexMap::iterator it = objectStore->m_indexes.begin(); it != objectStore->m_indexes.end(); ++it, ++i) {
237	putIndexData(objectStore->sqliteDatabase(), indexKeys[i].get(), it->second->id(), dataRowId);	244	if (!putIndexData(objectStore->sqliteDatabase(), indexKeys[i].get(), it->second->id(), dataRowId)) {
		245	// FIXME: The Indexed Database specification does not have an error code dedicated to I/O errors.
		246	callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Error writing data to stable storage."));
		247	transaction->abort();
		248	return;
		249	}
		250	}
238		251
239	callbacks->onSuccess(key.get());	252	callbacks->onSuccess(key.get());
240	}	253	}
Lines 287-300 PassRefPtr<IDBIndexBackendInterface> IDBObjectStoreBackendImpl::createIndex(cons a/WebCore/storage/IDBObjectStoreBackendImpl.cpp_sec4
287	void IDBObjectStoreBackendImpl::createIndexInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<IDBIndexBackendImpl> index, PassRefPtr<IDBTransactionBackendInterface> transaction)	300	void IDBObjectStoreBackendImpl::createIndexInternal(ScriptExecutionContext*, PassRefPtr<IDBObjectStoreBackendImpl> objectStore, PassRefPtr<IDBIndexBackendImpl> index, PassRefPtr<IDBTransactionBackendInterface> transaction)
288	{	301	{
289	SQLiteStatement insert(objectStore->sqliteDatabase(), "INSERT INTO Indexes (objectStoreId, name, keyPath, isUnique) VALUES (?, ?, ?, ?)");	302	SQLiteStatement insert(objectStore->sqliteDatabase(), "INSERT INTO Indexes (objectStoreId, name, keyPath, isUnique) VALUES (?, ?, ?, ?)");
290	bool ok = insert.prepare() == SQLResultOk;	303	if (!insert.prepare()) {
291	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.	304	transaction->abort();
		305	return;
		306	}
292	insert.bindInt64(1, objectStore->m_id);	307	insert.bindInt64(1, objectStore->m_id);
293	insert.bindText(2, index->name());	308	insert.bindText(2, index->name());
294	insert.bindText(3, index->keyPath());	309	insert.bindText(3, index->keyPath());
295	insert.bindInt(4, static_cast<int>(index->unique()));	310	insert.bindInt(4, static_cast<int>(index->unique()));
296	ok = insert.step() == SQLResultDone;	311	if (!insert.step()) {
297	ASSERT_UNUSED(ok, ok); // FIXME: Better error handling.	312	transaction->abort();
		313	return;
		314	}
298	int64_t id = objectStore->sqliteDatabase().lastInsertRowID();	315	int64_t id = objectStore->sqliteDatabase().lastInsertRowID();
299	index->setId(id);	316	index->setId(id);
300	transaction->didCompleteTaskEvents();	317	transaction->didCompleteTaskEvents();

Lines 1-3 a/LayoutTests/ChangeLog_sec1
- a/LayoutTests/ChangeLog +10 lines
		1	2010-10-08 Andrei Popescu <andreip@google.com>
		2
		3	Reviewed by NOBODY (OOPS!).
		4
		5	IndexedDB does not have a quota mechanism.
		6	https://bugs.webkit.org/show_bug.cgi?id=47389
		7
		8	* storage/indexeddb/database-quota-expected.txt: Added.
		9	* storage/indexeddb/database-quota.html: Added.
		10
1	2010-10-08 Renata Hodovan <reni@inf.u-szeged.hu>	11	2010-10-08 Renata Hodovan <reni@inf.u-szeged.hu>
2		12
3	Reviewed by Nikolas Zimmermann.	13	Reviewed by Nikolas Zimmermann.

Line 0 a/LayoutTests/storage/indexeddb/database-quota.html_sec1
- a/LayoutTests/storage/indexeddb/database-quota.html +126 lines
		1	<html>
		2	<head>
		3	<link rel="stylesheet" href="../../fast/js/resources/js-test-style.css">
		4	<script src="../../fast/js/resources/js-test-pre.js"></script>
		5	<script src="../../fast/js/resources/js-test-post-function.js"></script>
		6	<script src="resources/shared.js"></script>
		7	</head>
		8	<body>
		9	<p id="description"></p>
		10	<div id="console"></div>
		11	<script>
		12
		13	description("Tests IndexedDB's quota enforcing mechanism.");
		14	if (window.layoutTestController)
		15	layoutTestController.waitUntilDone();
		16
		17	function test()
		18	{
		19	result = evalAndLog("indexedDB.open('name', 'description')");
		20	verifyResult(result);
		21	result.onsuccess = openSuccess;
		22	result.onerror = unexpectedErrorCallback;
		23	}
		24
		25	function openSuccess()
		26	{
		27	verifySuccessEvent(event);
		28	window.db = evalAndLog("db = event.result");
		29
		30	result = evalAndLog("db.setVersion('new version')");
		31	verifyResult(result);
		32	result.onsuccess = setVersionSuccess;
		33	result.onerror = unexpectedErrorCallback;
		34	}
		35
		36	function setVersionSuccess()
		37	{
		38	debug("setVersionSuccess():");
		39	verifySuccessEvent(event);
		40	window.trans = evalAndLog("trans = event.result");
		41	shouldBeTrue("trans !== null");
		42	trans.onabort = unexpectedAbortCallback;
		43
		44	deleteAllObjectStores(db, createNewObjectStore);
		45	}
		46
		47	function createNewObjectStore()
		48	{
		49	verifySuccessEvent(event);
		50	shouldBeEqualToString("db.version", "version b");
		51	shouldBeEqualToString("db.name", "name");
		52	shouldBe("db.objectStores", "[]");
		53	shouldBe("db.objectStores.length", "0");
		54	shouldBe("db.objectStores.contains('')", "false");
		55
		56	objectStore = evalAndLog('db.createObjectStore("test123")');
		57	checkObjectStore();
		58	commitAndContinue();
		59	}
		60
		61	function checkObjectStore()
		62	{
		63	shouldBe("db.objectStores", "['test123']");
		64	shouldBe("db.objectStores.length", "1");
65	shouldBe("db.objectStores.contains('')", "false");
66	shouldBe("db.objectStores.contains('test456')", "false");
67	shouldBe("db.objectStores.contains('test123')", "true");
68	}
69
70	function commitAndContinue()
71	{
72	window.setTimeout(checkQuotaEnforcing, 0);
73	}
74
75	function checkQuotaEnforcing()
76	{
77	var trans = evalAndLog("trans = db.transaction()");
78	trans.onabort = testComplete;
79	trans.oncomplete = unexpectedCompleteCallback;
80	debug("Creating 'data' which contains 64K of data");
81	window.data = "X";
82	for (var i = 0; i < 16; i++)
83	data += data;
84	shouldBe("data.length", "65536");
85	window.dataAdded = 0;
86	window.store = evalAndLog("store = trans.objectStore('test123')");
87	addData();
88	}
89
90	function addData()
91	{
92	if (dataAdded < 5 * 1024 * 1024) {
93	if (dataAdded > 0) {
94	verifySuccessEvent(event);
95	store = evalAndLog("store = event.source");
96	}
97	} else {
98	testFailed("added more than quota");
99	done();
100	return;
101	}
102	dataAdded += 65536;
103	result = evalAndLog("store.add({x: data}, dataAdded)");
104	result.onsuccess = addData;
105	result.onerror = logError;
106	}
107
108	function logError()
109	{
110	debug("Error function called: (" + event.code + ") " + event.message);
111	verifyErrorEvent(event);
112	}
113
114	function testComplete()
115	{
116	testPassed("Adding data failed due to quota error. Data added was: " + dataAdded / 1024 + " KB");
117	done();
118	}
119
120	test();
121
122	var successfullyParsed = true;
123
124	</script>
125	</body>
126	</html>

Lines 1-3 a/WebCore/ChangeLog_sec1
- a/WebCore/ChangeLog +39 lines
		1	2010-10-08 Andrei Popescu <andreip@google.com>
		2
		3	Reviewed by NOBODY (OOPS!).
		4
		5	IndexedDB does not have a quota mechanism.
		6	https://bugs.webkit.org/show_bug.cgi?id=47389
		7
		8	Test: storage/indexeddb/database-quota.html
		9
		10	Add a simple mechanism for enforcing a maximum size
		11	for each origin using IndexedDB. Note that this depends
		12	on having one SQLite database file per origin, which is
		13	addressed in a separate patch.
		14
		15	* page/GroupSettings.cpp:
		16	(WebCore::GroupSettings::GroupSettings):
		17	(WebCore::GroupSettings::setIndexedDBQuotaBytes):
		18	* page/GroupSettings.h:
		19	(WebCore::GroupSettings::indexedDBQuotaBytes):
		20	* storage/IDBDatabaseBackendImpl.cpp:
		21	(WebCore::IDBDatabaseBackendImpl::createObjectStore):
		22	(WebCore::IDBDatabaseBackendImpl::createObjectStoreInternal):
		23	(WebCore::IDBDatabaseBackendImpl::removeObjectStore):
		24	(WebCore::IDBDatabaseBackendImpl::setVersionInternal):
		25	* storage/IDBFactory.cpp:
		26	(WebCore::IDBFactory::open):
		27	* storage/IDBFactoryBackendImpl.cpp:
		28	(WebCore::openSQLiteDatabase):
		29	(WebCore::IDBFactoryBackendImpl::open):
		30	* storage/IDBFactoryBackendImpl.h:
		31	* storage/IDBFactoryBackendInterface.h:
		32	* storage/IDBObjectStoreBackendImpl.cpp:
		33	(WebCore::putObjectStoreData):
		34	(WebCore::putIndexData):
		35	(WebCore::IDBObjectStoreBackendImpl::put):
		36	(WebCore::IDBObjectStoreBackendImpl::putInternal):
		37	(WebCore::IDBObjectStoreBackendImpl::createIndexInternal):
		38	* storage/IDBObjectStoreBackendImpl.h:
		39
1	2010-10-08 Benjamin Poulain <benjamin.poulain@nokia.com>	40	2010-10-08 Benjamin Poulain <benjamin.poulain@nokia.com>
2		41
3	Reviewed by Andreas Kling.	42	Reviewed by Andreas Kling.

Lines 68-74 PassRefPtr<IDBRequest> IDBFactory::open(ScriptExecutionContext* context, const S a/WebCore/storage/IDBFactory.cpp_sec1
- a/WebCore/storage/IDBFactory.cpp -1 / +2 lines
68	return 0;	68	return 0;
69		69
70	RefPtr<IDBRequest> request = IDBRequest::create(document, IDBAny::create(this), 0);	70	RefPtr<IDBRequest> request = IDBRequest::create(document, IDBAny::create(this), 0);
71	m_factoryBackend->open(name, description, request, document->securityOrigin(), document->frame(), document->page()->group().groupSettings()->indexedDBDatabasePath());	71	GroupSettings* groupSettings = document->page()->group().groupSettings();
		72	m_factoryBackend->open(name, description, request, document->securityOrigin(), document->frame(), groupSettings->indexedDBDatabasePath(), groupSettings->indexedDBQuotaBytes());
72	return request;	73	return request;
73	}	74	}
74		75

Lines 52-58 IDBFactoryBackendImpl::~IDBFactoryBackendImpl() a/WebCore/storage/IDBFactoryBackendImpl.cpp_sec1
- a/WebCore/storage/IDBFactoryBackendImpl.cpp -3 / +4 lines
52	{	52	{
53	}	53	}
54		54
55	static PassOwnPtr<SQLiteDatabase> openSQLiteDatabase(SecurityOrigin* securityOrigin, String name, const String& pathBase)	55	static PassOwnPtr<SQLiteDatabase> openSQLiteDatabase(SecurityOrigin* securityOrigin, String name, const String& pathBase, int64_t maximumSize)
56	{	56	{
57	String path = ":memory:";	57	String path = ":memory:";
58	if (!pathBase.isEmpty()) {	58	if (!pathBase.isEmpty()) {
Lines 72-77 static PassOwnPtr<SQLiteDatabase> openSQLiteDatabase(SecurityOrigin* securityOri a/WebCore/storage/IDBFactoryBackendImpl.cpp_sec2
72	return 0;	72	return 0;
73	}	73	}
74		74
		75	sqliteDatabase->setMaximumSize(maximumSize);
75	return sqliteDatabase.release();	76	return sqliteDatabase.release();
76	}	77	}
77		78
Lines 117-123 static bool createTables(SQLiteDatabase* sqliteDatabase) a/WebCore/storage/IDBFactoryBackendImpl.cpp_sec3
117	return true;	118	return true;
118	}	119	}
119		120
120	void IDBFactoryBackendImpl::open(const String& name, const String& description, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> securityOrigin, Frame*, const String& dataDir)	121	void IDBFactoryBackendImpl::open(const String& name, const String& description, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> securityOrigin, Frame*, const String& dataDir, int64_t maximumSize)
121	{	122	{
122	IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(name);	123	IDBDatabaseBackendMap::iterator it = m_databaseBackendMap.find(name);
123	if (it != m_databaseBackendMap.end()) {	124	if (it != m_databaseBackendMap.end()) {
Lines 129-135 void IDBFactoryBackendImpl::open(const String& name, const String& description, a/WebCore/storage/IDBFactoryBackendImpl.cpp_sec4
129		130
130	// FIXME: Everything from now on should be done on another thread.	131	// FIXME: Everything from now on should be done on another thread.
131		132
132	OwnPtr<SQLiteDatabase> sqliteDatabase = openSQLiteDatabase(securityOrigin.get(), name, dataDir);	133	OwnPtr<SQLiteDatabase> sqliteDatabase = openSQLiteDatabase(securityOrigin.get(), name, dataDir, maximumSize);
133	if (!sqliteDatabase \|\| !createTables(sqliteDatabase.get())) {	134	if (!sqliteDatabase \|\| !createTables(sqliteDatabase.get())) {
134	callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Internal error."));	135	callbacks->onError(IDBDatabaseError::create(IDBDatabaseException::UNKNOWN_ERR, "Internal error."));
135	return;	136	return;

Lines 1-3 a/WebKit/chromium/ChangeLog_sec1
- a/WebKit/chromium/ChangeLog +16 lines
		1	2010-10-08 Andrei Popescu <andreip@google.com>
		2
		3	Reviewed by NOBODY (OOPS!).
		4
		5	IndexedDB does not have a quota mechanism.
		6	https://bugs.webkit.org/show_bug.cgi?id=47389
		7
		8	* public/WebIDBFactory.h:
		9	(WebKit::WebIDBFactory::open):
		10	* src/IDBFactoryBackendProxy.cpp:
		11	(WebCore::IDBFactoryBackendProxy::open):
		12	* src/IDBFactoryBackendProxy.h:
		13	* src/WebIDBFactoryImpl.cpp:
		14	(WebKit::WebIDBFactoryImpl::open):
		15	* src/WebIDBFactoryImpl.h:
		16
1	2010-10-07 Zhenyao Mo <zmo@google.com>	17	2010-10-07 Zhenyao Mo <zmo@google.com>
2		18
3	Unreviewed, roll chromium to r61902.	19	Unreviewed, roll chromium to r61902.

Lines 59-68 IDBFactoryBackendProxy::~IDBFactoryBackendProxy() a/WebKit/chromium/src/IDBFactoryBackendProxy.cpp_sec1
- a/WebKit/chromium/src/IDBFactoryBackendProxy.cpp -2 / +2 lines
59	{	59	{
60	}	60	}
61		61
62	void IDBFactoryBackendProxy::open(const String& name, const String& description, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> origin, Frame* frame, const String& dataDir)	62	void IDBFactoryBackendProxy::open(const String& name, const String& description, PassRefPtr<IDBCallbacks> callbacks, PassRefPtr<SecurityOrigin> origin, Frame* frame, const String& dataDir, int64_t maximumSize)
63	{	63	{
64	WebKit::WebFrame* webFrame = WebKit::WebFrameImpl::fromFrame(frame);	64	WebKit::WebFrame* webFrame = WebKit::WebFrameImpl::fromFrame(frame);
65	m_webIDBFactory->open(name, description, new WebIDBCallbacksImpl(callbacks), origin, webFrame, dataDir);	65	m_webIDBFactory->open(name, description, new WebIDBCallbacksImpl(callbacks), origin, webFrame, dataDir, maximumSize);
66	}	66	}
67		67
68	} // namespace WebCore	68	} // namespace WebCore

Lines 58-66 WebIDBFactoryImpl::~WebIDBFactoryImpl() a/WebKit/chromium/src/WebIDBFactoryImpl.cpp_sec1
- a/WebKit/chromium/src/WebIDBFactoryImpl.cpp -2 / +2 lines
58	{	58	{
59	}	59	}
60		60
61	void WebIDBFactoryImpl::open(const WebString& name, const WebString& description, WebIDBCallbacks* callbacks, const WebSecurityOrigin& origin, WebFrame*, const WebString& dataDir)	61	void WebIDBFactoryImpl::open(const WebString& name, const WebString& description, WebIDBCallbacks* callbacks, const WebSecurityOrigin& origin, WebFrame*, const WebString& dataDir, unsigned long long maximumSize)
62	{	62	{
63	m_idbFactoryBackend->open(name, description, IDBCallbacksProxy::create(callbacks), origin, 0, dataDir);	63	m_idbFactoryBackend->open(name, description, IDBCallbacksProxy::create(callbacks), origin, 0, dataDir, maximumSize);
64	}	64	}
65		65
66	} // namespace WebKit	66	} // namespace WebKit