[IndexedDB]: Implement explicit commit() in renderer

Implementing an explicit commit function for the IndexedDB Transaction API.
The addition of this API allows developers to preempt IndexedDB's autocommit
functionality by sending their own explicit commit signal.

Explainer: https://andreas-butler.github.io/idb-transaction-commit/EXPLAINER
Bug: https://bugs.chromium.org/p/chromium/issues/detail?id=898257
Change-Id: I5e8bdc697052139d014757408d9a7f2b6367655b
Reviewed-on: https://chromium-review.googlesource.com/c/1300055
Commit-Queue: Andreas Butler <andreasbutler@google.com>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Reviewed-by: Daniel Murphy <dmurph@chromium.org>
Cr-Commit-Position: refs/heads/master@{#612474}

content/browser/indexed_db/indexed_db_transaction.cc

@@ -4,6 +4,9 @@
 
 #include "content/browser/indexed_db/indexed_db_transaction.h"
 
+#include <utility>
+#include <vector>
+
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ -332,7 +335,6 @@ leveldb::Status IndexedDBTransaction::Commit() {
     return leveldb::Status::OK();
   DCHECK_NE(state_, COMMITTING);
 
-  DCHECK(!used_ || state_ == STARTED);
   commit_pending_ = true;
 
   // Front-end has requested a commit, but this transaction is blocked by

third_party/blink/renderer/modules/indexeddb/idb_transaction.cc

@@ -26,6 +26,7 @@
 #include "third_party/blink/renderer/modules/indexeddb/idb_transaction.h"
 
 #include <memory>
+#include <utility>
 
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
 #include "third_party/blink/renderer/core/dom/events/event_queue.h"
@@ -361,6 +362,30 @@ void IDBTransaction::abort(ExceptionState& exception_state) {
     BackendDB()->Abort(id_);
 }
 
+void IDBTransaction::commit(ExceptionState& exception_state) {
+  if (state_ == kFinishing || state_ == kFinished) {
+    exception_state.ThrowDOMException(
+        DOMExceptionCode::kInvalidStateError,
+        IDBDatabase::kTransactionFinishedErrorMessage);
+    return;
+  }
+
+  if (state_ == kInactive) {
+    exception_state.ThrowDOMException(
+        DOMExceptionCode::kInvalidStateError,
+        IDBDatabase::kTransactionInactiveErrorMessage);
+    return;
+  }
+
+  if (!GetExecutionContext())
+    return;
+
+  state_ = kFinishing;
+
+  if (BackendDB())
+    BackendDB()->Commit(id_);
+}
+
 void IDBTransaction::RegisterRequest(IDBRequest* request) {
   DCHECK(request);
   DCHECK(!request_list_.Contains(request));

third_party/blink/renderer/modules/indexeddb/idb_transaction.h

@@ -128,6 +128,7 @@ class MODULES_EXPORT IDBTransaction final
   DOMException* error() const { return error_; }
   IDBObjectStore* objectStore(const String& name, ExceptionState&);
   void abort(ExceptionState&);
+  void commit(ExceptionState&);
 
   void RegisterRequest(IDBRequest*);
   void UnregisterRequest(IDBRequest*);

third_party/blink/renderer/modules/indexeddb/idb_transaction.idl

@@ -46,8 +46,12 @@ enum IDBTransactionMode {
     readonly attribute DOMException error;
 
     // Methods
-    [RaisesException] IDBObjectStore objectStore (DOMString name);
-    [RaisesException] void abort ();
+    [RaisesException] IDBObjectStore objectStore(DOMString name);
+    [
+      RaisesException,
+      RuntimeEnabled=IDBTransactionCommit
+    ] void commit();
+    [RaisesException] void abort();
 
     // Events
     attribute EventHandler onabort;

third_party/blink/renderer/platform/runtime_enabled_features.json5

@@ -605,6 +605,10 @@
       name: "IDBObserver",
       status: "experimental",
     },
+    {
+      name: "IDBTransactionCommit",
+      status: "experimental",
+    },
     {
       name: "IgnoreCrossOriginWindowWhenNamedAccessOnWindow",
       status: "experimental",

third_party/blink/web_tests/external/wpt/IndexedDB/idb-explicit-commit-throw.any.js

+// META: script=support-promises.js
+
+/**
+ * This file contains a test that was separated out from the rest of the idb
+ * explict commit tests because it requires the flag 'allow_uncaught_exception',
+ * which prevents unintentionally thrown errors from failing tests.
+ *
+ * @author andreasbutler@google.com
+ */
+
+setup({allow_uncaught_exception:true});
+
+promise_test(async testCase => {
+  // Register an event listener that will prevent the intentionally thrown
+  // error from bubbling up to the window and failing the testharness. This
+  // is necessary because currently allow_uncaught_exception does not behave
+  // as expected for promise_test.
+  //
+  // Git issue: https://github.com/web-platform-tests/wpt/issues/14041
+  self.addEventListener('error', (event) => { event.preventDefault(); });
+
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  const putRequest = objectStore.put({isbn:'one', title:'title'});
+  txn.commit();
+  putRequest.onsuccess = () => {
+    throw new Error('This error thrown after an explicit commit should not ' +
+        'prevent the transaction from committing.');
+  }
+  await promiseForTransaction(testCase, txn);
+
+  // Ensure that despite the uncaught error after the put request, the explicit
+  // commit still causes the request to be committed.
+  const txn2 = db.transaction(['books'], 'readwrite');
+  const objectStore2 = txn2.objectStore('books');
+  const getRequest = objectStore2.get('one');
+  await promiseForTransaction(testCase, txn2);
+
+  assert_equals(getRequest.result.title, 'title');
+}, 'Any errors in callbacks that run after an explicit commit will not stop '
+   + 'the commit from being processed.');

third_party/blink/web_tests/external/wpt/IndexedDB/idb-explicit-commit.any.js

+// META: script=support-promises.js
+
+/**
+ * This file contains the webplatform tests for the explicit commit() method
+ * of the IndexedDB transaction API.
+ *
+ * @author andreasbutler@google.com
+ */
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  objectStore.put({isbn: 'one', title: 'title1'});
+  objectStore.put({isbn: 'two', title: 'title2'});
+  objectStore.put({isbn: 'three', title: 'title3'});
+  txn.commit();
+  await promiseForTransaction(testCase, txn);
+
+  const txn2 = db.transaction(['books'], 'readonly');
+  const objectStore2 = txn2.objectStore('books');
+  const getRequestitle1 = objectStore2.get('one');
+  const getRequestitle2 = objectStore2.get('two');
+  const getRequestitle3 = objectStore2.get('three');
+  txn2.commit();
+  await promiseForTransaction(testCase, txn2);
+  assert_array_equals(
+      [getRequestitle1.result.title,
+          getRequestitle2.result.title,
+          getRequestitle3.result.title],
+      ['title1', 'title2', 'title3'],
+      'All three retrieved titles should match those that were put.');
+  db.close();
+}, 'Explicitly committed data can be read back out.');
+
+
+promise_test(async testCase => {
+  let db = await createDatabase(testCase, () => {});
+  assert_equals(1, db.version, 'A database should be created as version 1');
+  db.close();
+
+  // Upgrade the versionDB database and explicitly commit its versionchange
+  // transaction.
+  db = await migrateDatabase(testCase, 2, async (db, txn) => {
+    txn.commit();
+  });
+  assert_equals(2, db.version,
+      'The database version should have been incremented regardless of '
+      + 'whether the versionchange transaction was explicitly or implicitly '
+      + 'committed.');
+  db.close();
+}, 'commit() on a version change transaction does not cause errors.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  txn.commit();
+  assert_throws('TransactionInactiveError',
+      () => { objectStore.put({isbn: 'one', title: 'title1'}); },
+      'After commit is called, the transaction should be inactive.');
+  db.close();
+}, 'A committed transaction becomes inactive immediately.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  const putRequest = objectStore.put({isbn: 'one', title: 'title1'});
+  putRequest.onsuccess = testCase.step_func(() => {
+    assert_throws('TransactionInactiveError',
+      () => { objectStore.put({isbn:'two', title:'title2'}); },
+      'The transaction should not be active in the callback of a request after '
+      + 'commit() is called.');
+  });
+  txn.commit();
+  await promiseForTransaction(testCase, txn);
+  db.close();
+}, 'A committed transaction is inactive in future request callbacks.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  txn.commit();
+
+  assert_throws('TransactionInactiveError',
+      () => { objectStore.put({isbn:'one', title:'title1'}); },
+      'After commit is called, the transaction should be inactive.');
+
+  const txn2 = db.transaction(['books'], 'readonly');
+  const objectStore2 = txn2.objectStore('books');
+  const getRequest = objectStore2.get('one');
+  await promiseForTransaction(testCase, txn2);
+  assert_equals(getRequest.result, undefined);
+
+  db.close();
+}, 'Puts issued after commit are not fulfilled.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  txn.abort();
+  assert_throws('InvalidStateError',
+      () => { txn.commit(); },
+      'The transaction should have been aborted.');
+  db.close();
+}, 'Calling commit on an aborted transaction throws.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  txn.commit();
+  assert_throws('InvalidStateError',
+      () => { txn.commit(); },
+      'The transaction should have already committed.');
+  db.close();
+}, 'Calling commit on a committed transaction throws.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  const putRequest = objectStore.put({isbn:'one', title:'title1'});
+  txn.commit();
+  assert_throws('InvalidStateError',
+      () => { txn.abort(); },
+      'The transaction should already have committed.');
+  const txn2 = db.transaction(['books'], 'readwrite');
+  const objectStore2 = txn2.objectStore('books');
+  const getRequest = objectStore2.get('one');
+  await promiseForTransaction(testCase, txn2);
+  assert_equals(
+      getRequest.result.title,
+      'title1',
+      'Explicitly committed data should be gettable.');
+  db.close();
+}, 'Calling abort on a committed transaction throws and does not prevent '
+   + 'persisting the data.');
+
+
+promise_test(async testCase => {
+  const db = await createDatabase(testCase, async db => {
+    await createBooksStore(testCase, db);
+  });
+  const txn = db.transaction(['books'], 'readwrite');
+  const objectStore = txn.objectStore('books');
+  const releaseTxnFunction = keepAlive(testCase, txn, 'books');
+
+  // Break up the scope of execution to force the transaction into an inactive
+  // state.
+  await timeoutPromise(0);
+
+  assert_throws('InvalidStateError',
+      () => { txn.commit(); },
+      'The transaction should be inactive so calling commit should throw.');
+  releaseTxnFunction();
+  db.close();
+}, 'Calling txn.commit() when txn is inactive should throw.');

third_party/blink/web_tests/external/wpt/IndexedDB/support-promises.js

@@ -312,3 +312,32 @@ async function deleteAllDatabases(testCase) {
     await eventWatcher.wait_for('success');
   }
 }
+
+// Keeps the passed transaction alive indefinitely (by making requests
+// against the named store). Returns a function that asserts that the
+// transaction has not already completed and then ends the request loop so that
+// the transaction may autocommit and complete.
+function keepAlive(testCase, transaction, storeName) {
+  let completed = false;
+  transaction.addEventListener('complete', () => { completed = true; });
+
+  let keepSpinning = true;
+
+  function spin() {
+    if (!keepSpinning)
+      return;
+    transaction.objectStore(storeName).get(0).onsuccess = spin;
+  }
+  spin();
+
+  return testCase.step_func(() => {
+    assert_false(completed, 'Transaction completed while kept alive');
+    keepSpinning = false;
+  });
+}
+
+// Return a promise that resolves after a setTimeout finishes to break up the
+// scope of a function's execution.
+function timeoutPromise(ms) {
+  return new Promise(resolve => { setTimeout(resolve, ms); });
+}

third_party/blink/web_tests/external/wpt/IndexedDB/support.js

-var databaseName = "database";
-var databaseVersion = 1;
-
 /* Delete created databases
  *
  * Go through each finished test, see if it has an associated database. Close
@@ -170,18 +167,18 @@ function is_transaction_active(tx, store_name) {
   }
 }
 
-// Keep the passed transaction alive indefinitely (by making requests
-// against the named store). Returns a function to to let the
-// transaction finish, and asserts that the transaction is not yet
-// finished.
+// Keeps the passed transaction alive indefinitely (by making requests
+// against the named store). Returns a function that asserts that the
+// transaction has not already completed and then ends the request loop so that
+// the transaction may autocommit and complete.
 function keep_alive(tx, store_name) {
   let completed = false;
   tx.addEventListener('complete', () => { completed = true; });
 
-  let pin = true;
+  let keepSpinning = true;
 
   function spin() {
-    if (!pin)
+    if (!keepSpinning)
       return;
     tx.objectStore(store_name).get(0).onsuccess = spin;
   }
@@ -189,6 +186,6 @@ function keep_alive(tx, store_name) {
 
   return () => {
     assert_false(completed, 'Transaction completed while kept alive');
-    pin = false;
+    keepSpinning = false;
   };
 }

third_party/blink/web_tests/http/tests/serviceworker/webexposed/global-interface-listing-service-worker-expected.txt

@@ -674,6 +674,7 @@ interface IDBTransaction : EventTarget
     getter oncomplete
     getter onerror
     method abort
+    method commit
     method constructor
     method objectStore
     setter onabort

third_party/blink/web_tests/webexposed/global-interface-listing-dedicated-worker-expected.txt

@@ -615,6 +615,7 @@ Starting worker: resources/global-interface-listing-worker.js
 [Worker]     getter oncomplete
 [Worker]     getter onerror
 [Worker]     method abort
+[Worker]     method commit
 [Worker]     method constructor
 [Worker]     method objectStore
 [Worker]     setter onabort

third_party/blink/web_tests/webexposed/global-interface-listing-expected.txt

@@ -4023,6 +4023,7 @@ interface IDBTransaction : EventTarget
     getter oncomplete
     getter onerror
     method abort
+    method commit
     method constructor
     method objectStore
     setter onabort

third_party/blink/web_tests/webexposed/global-interface-listing-shared-worker-expected.txt

@@ -610,6 +610,7 @@ Starting worker: resources/global-interface-listing-worker.js
 [Worker]     getter oncomplete
 [Worker]     getter onerror
 [Worker]     method abort
+[Worker]     method commit
 [Worker]     method constructor
 [Worker]     method objectStore
 [Worker]     setter onabort