Port IndexedDB Blob Web Tests to web-platform-tests.

This CL ports the Blob related IndexedDB Web Tests to WPT tests.

Bug: 866164

Change-Id: Ie2b1b6ddc0c1ddbbb92478a2d5c81bd669c30e45
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1807963
Reviewed-by: Joshua Bell <[email protected]>
Commit-Queue: Sertay Sener <[email protected]>
Cr-Commit-Position: refs/heads/master@{#704755}

Author: Sertay Sener

IndexedDB/blob-contenttype.any.js

@@ -0,0 +1,38 @@
+// META: title=Blob Content Type
+// META: script=support.js
+
+indexeddb_test(
+    function upgrade(t, db) {
+        db.createObjectStore('store');
+    },
+    function success(t, db) {
+        var type = 'x-files/trust-no-one';
+
+        var blob = new Blob(['mulder', 'scully'], {type: type});
+        assert_equals(blob.type, type, 'Blob type should match constructor option');
+
+        var tx = db.transaction('store', 'readwrite');
+        tx.objectStore('store').put(blob, 'key');
+
+        tx.oncomplete = t.step_func(function() {
+            var tx = db.transaction('store');
+            tx.objectStore('store').get('key').onsuccess = t.step_func(function(e) {
+                var result = e.target.result;
+                assert_equals(result.type, type, 'Blob type should survive round-trip');
+
+                var url = URL.createObjectURL(result);
+                var xhr = new XMLHttpRequest(), async = true;
+                xhr.open('GET', url, async);
+                xhr.send();
+                xhr.onreadystatechange = t.step_func(function() {
+                    if (xhr.readyState !== XMLHttpRequest.DONE)
+                        return;
+                    assert_equals(xhr.getResponseHeader('Content-Type'), type,
+                                  'Blob type should be preserved when fetched');
+                    t.done();
+                });
+            });
+        });
+    },
+    'Ensure that content type round trips when reading blob data'
+);

IndexedDB/blob-delete-objectstore-db.any.js

@@ -0,0 +1,47 @@
+// META: title=Blob Delete Object Store
+// META: script=support.js
+
+let key = "blob key";
+
+indexeddb_test(
+    function upgrade(t, db) {
+      const store0 = db.createObjectStore('store0');
+      const store1 = db.createObjectStore('store1');
+
+      const blobAContent = "First blob content";
+      const blobA = new Blob([blobAContent], {"type" : "text/plain"});
+
+      store0.put(blobA, key);
+    },
+    function success(t, db) {
+      db.close();
+      const request = indexedDB.open(db.name, 2);
+
+      request.onupgradeneeded = t.step_func(function(e) {
+        const db = e.target.result;
+        db.deleteObjectStore('store0');
+
+        request.onsuccess = t.step_func(function() {
+          const blobBContent = "Second blob content";
+          const trans = db.transaction('store1', 'readwrite');
+          const store1 = trans.objectStore('store1');
+          const blobB = new Blob([blobBContent], {"type" : "text/plain"});
+          store1.put(blobB, key);
+
+          trans.oncomplete = t.step_func(function() {
+            db.close();
+            const delete_request = indexedDB.deleteDatabase(db.name);
+
+            // The test passes if it successfully completes.
+            delete_request.onsuccess = t.step_func_done();
+
+            delete_request.onerror = t.unreached_func("Request should not fail.");
+          });
+
+          trans.onabort = t.unreached_func("Transaction should not be aborted.");
+        });
+      });
+      request.onsuccess = t.unreached_func("Request should not succeed without an upgrade.");
+      request.onerror = t.unreached_func("Request should not fail.");
+      request.onblocked = t.unreached_func("Request should not be blocked.");
+    }, "Deleting an object store and a database containing blobs doesn't crash.");

IndexedDB/blob-valid-after-deletion.any.js

@@ -0,0 +1,53 @@
+// META: title=Blob Valid After Deletion
+// META: script=support.js
+
+let key = "key";
+
+indexeddb_test(
+  function upgrade(t, db) {
+    db.createObjectStore('store');
+  },
+  function success(t, db) {
+    const blobAContent = "Blob A content";
+    const blobBContent = "Blob B content";
+    const blobA = new Blob([blobAContent], {"type" : "text/plain"});
+    const blobB = new Blob([blobBContent], {"type" : "text/plain"});
+    value = { a0: blobA, a1: blobA, b0: blobB };
+
+    const tx = db.transaction('store', 'readwrite');
+    var store = tx.objectStore('store');
+
+    store.put(value, key);
+    value = null;
+
+    const trans = db.transaction('store');
+    store = trans.objectStore('store');
+    const request = store.get(key);
+
+    request.onsuccess = t.step_func(function() {
+      const record = request.result;
+
+      trans.oncomplete = t.step_func(function() {
+        const trans = db.transaction('store', 'readwrite');
+        store = trans.objectStore('store');
+        const request = store.delete(key);
+
+        trans.oncomplete = t.step_func(function() {
+          const promise1 = record.a0.text().then(t.step_func(text => { assert_equals(text, blobAContent); },
+            t.unreached_func()));
+
+          const promise2 = record.a1.text().then(t.step_func(text => { assert_equals(text, blobAContent); },
+            t.unreached_func()));
+
+          const promise3 = record.b0.text().then(t.step_func(text => { assert_equals(text, blobBContent); },
+            t.unreached_func()));
+
+          Promise.all([promise1, promise2, promise3]).then(function() {
+            // The test passes if it successfully completes.
+            t.done();
+          });
+        });
+      });
+    });
+  },
+  "Blobs stay alive after their records are deleted.");

IndexedDB/blob-valid-before-commit.any.js

@@ -0,0 +1,41 @@
+// META: title=Blob Valid Before Commit
+// META: script=support.js
+
+let key = "key";
+
+indexeddb_test(
+    function upgrade(t, db) {
+        db.createObjectStore('store');
+    },
+    function success(t, db) {
+      const blobAContent = "Blob A content";
+      const blobBContent = "Blob B content";
+      const blobA = new Blob([blobAContent], {"type" : "text/plain"});
+      const blobB = new Blob([blobBContent], {"type" : "text/plain"});
+      const value = { a0: blobA, a1: blobA, b0: blobB };
+
+      const tx = db.transaction('store', 'readwrite');
+      const store = tx.objectStore('store');
+
+      store.put(value, key);
+      const request = store.get(key);
+
+      request.onsuccess = t.step_func(function() {
+        const record = request.result;
+
+        const promise1 = record.a0.text().then(t.step_func(text => { assert_equals(text, blobAContent); },
+            t.unreached_func()));
+
+        const promise2 = record.a1.text().then(t.step_func(text => { assert_equals(text, blobAContent); },
+            t.unreached_func()));
+
+        const promise3 = record.b0.text().then(t.step_func(text => { assert_equals(text, blobBContent); },
+            t.unreached_func()));
+
+        Promise.all([promise1, promise2, promise3]).then(function() {
+          // The test passes if it successfully completes.
+          t.done();
+        });
+      });
+    },
+    "Blobs can be read back before their records are committed.");