Ensure correctness for interleaved IndexedDB cursor iteration.

third_party/WebKit/LayoutTests/external/wpt/IndexedDB/support-promises.js

 'use strict';
 
 // Returns an IndexedDB database name that is unique to the test case.
 function databaseName(testCase) {
   return 'db' + self.location.pathname + '-' + testCase.name;
 }
 
 // Creates an EventWatcher covering all the events that can be issued by
 // IndexedDB requests and transactions.
 function requestWatcher(testCase, request) {
   return new EventWatcher(testCase, request,
       ['abort', 'blocked', 'complete', 'error', 'success', 'upgradeneeded']);
 }
 
 // Migrates an IndexedDB database whose name is unique for the test case.
 //
 // newVersion must be greater than the database's current version.
 //
 // migrationCallback will be called during a versionchange transaction and will
 // given the created database, the versionchange transaction, and the database
 // open request.
 //
 // Returns a promise. If the versionchange transaction goes through, the promise
-// resolves to an IndexedDB database that must be closed by the caller. If the
+// resolves to an IndexedDB database that should be closed by the caller. If the
 // versionchange transaction is aborted, the promise resolves to an error.
 function migrateDatabase(testCase, newVersion, migrationCallback) {
   return migrateNamedDatabase(
       testCase, databaseName(testCase), newVersion, migrationCallback);
 }
 
 // Migrates an IndexedDB database.
 //
 // newVersion must be greater than the database's current version.
 //
 // migrationCallback will be called during a versionchange transaction and will
 // given the created database, the versionchange transaction, and the database
 // open request.
 //
 // Returns a promise. If the versionchange transaction goes through, the promise
-// resolves to an IndexedDB database that must be closed by the caller. If the
+// resolves to an IndexedDB database that should be closed by the caller. If the
 // versionchange transaction is aborted, the promise resolves to an error.
 function migrateNamedDatabase(
     testCase, databaseName, newVersion, migrationCallback) {
   // We cannot use eventWatcher.wait_for('upgradeneeded') here, because
   // the versionchange transaction auto-commits before the Promise's then
   // callback gets called.
   return new Promise((resolve, reject) => {
     const request = indexedDB.open(databaseName, newVersion);
     request.onupgradeneeded = testCase.step_func(event => {
       const database = event.target.result;
@@ skipping 30 matching lines @@
         request.onsuccess = null;
         requestEventPromise =
             requestWatcher(testCase, request).wait_for('success');
       }
 
       // requestEventPromise needs to be the last promise in the chain, because
       // we want the event that it resolves to.
       resolve(Promise.resolve(callbackResult).then(() => requestEventPromise));
     });
     request.onerror = event => reject(event.target.error);
-    request.onsuccess = () => reject(new Error(
-        'indexedDB.open should not succeed without creating a ' +
-        'versionchange transaction'));
-  }).then(event => event.target.result || event.target.error);
+    request.onsuccess = () => {
+      const database = request.result;
+      testCase.add_cleanup(() => { database.close(); });
+      reject(new Error(
+          'indexedDB.open should not succeed without creating a ' +
+          'versionchange transaction'));
+    };
+  }).then(event => {
+    const database = event.target.result;
+    if (database) {
+      testCase.add_cleanup(() => { database.close(); });
+    }
+    return database || event.target.error;
+  });
 }
 
 // Creates an IndexedDB database whose name is unique for the test case.
 //
 // setupCallback will be called during a versionchange transaction, and will be
 // given the created database, the versionchange transaction, and the database
 // open request.
 //
-// Returns a promise that resolves to an IndexedDB database. The caller must
+// Returns a promise that resolves to an IndexedDB database. The caller should
 // close the database.
 function createDatabase(testCase, setupCallback) {
   return createNamedDatabase(testCase, databaseName(testCase), setupCallback);
 }
 
 // Creates an IndexedDB database.
 //
 // setupCallback will be called during a versionchange transaction, and will be
 // given the created database, the versionchange transaction, and the database
 // open request.
 //
-// Returns a promise that resolves to an IndexedDB database. The caller must
+// Returns a promise that resolves to an IndexedDB database. The caller should
 // close the database.
 function createNamedDatabase(testCase, databaseName, setupCallback) {
   const request = indexedDB.deleteDatabase(databaseName);
   const eventWatcher = requestWatcher(testCase, request);
 
-  return eventWatcher.wait_for('success').then(event =>
-      migrateNamedDatabase(testCase, databaseName, 1, setupCallback));
+  return eventWatcher.wait_for('success').then(event => {
+    testCase.add_cleanup(() => { indexedDB.deleteDatabase(databaseName); });
+    return migrateNamedDatabase(testCase, databaseName, 1, setupCallback)
+  });
 }
 
 // Opens an IndexedDB database without performing schema changes.
 //
 // The given version number must match the database's current version.
 //
-// Returns a promise that resolves to an IndexedDB database. The caller must
+// Returns a promise that resolves to an IndexedDB database. The caller should
 // close the database.
 function openDatabase(testCase, version) {
   return openNamedDatabase(testCase, databaseName(testCase), version);
 }
 
 // Opens an IndexedDB database without performing schema changes.
 //
 // The given version number must match the database's current version.
 //
-// Returns a promise that resolves to an IndexedDB database. The caller must
+// Returns a promise that resolves to an IndexedDB database. The caller should
 // close the database.
 function openNamedDatabase(testCase, databaseName, version) {
   const request = indexedDB.open(databaseName, version);
   const eventWatcher = requestWatcher(testCase, request);
-  return eventWatcher.wait_for('success').then(event => event.target.result);
+  return eventWatcher.wait_for('success').then(() => {
+    const database = request.result;
+    testCase.add_cleanup(() => { database.close(); });
+    return database;
+  });
 }
 
 // The data in the 'books' object store records in the first example of the
 // IndexedDB specification.
 const BOOKS_RECORD_DATA = [
   { title: 'Quarry Memories', author: 'Fred', isbn: 123456 },
   { title: 'Water Buffaloes', author: 'Fred', isbn: 234567 },
   { title: 'Bedrock Nights', author: 'Barney', isbn: 345678 },
 ];
 
@@ skipping 92 matching lines @@
 // is using it incorrectly.
 function checkTitleIndexContents(testCase, index, errorMessage) {
   const request = index.get(BOOKS_RECORD_DATA[2].title);
   const eventWatcher = requestWatcher(testCase, request);
   return eventWatcher.wait_for('success').then(() => {
     const result = request.result;
     assert_equals(result.isbn, BOOKS_RECORD_DATA[2].isbn, errorMessage);
     assert_equals(result.author, BOOKS_RECORD_DATA[2].author, errorMessage);
   });
 }