Fire window.onerror for uncaught IndexedDB errors

third_party/WebKit/LayoutTests/resources/js-test.js

 // js-test now supports lazily printing test results which dumps all test
 // results once at the end of the test instead of building them up. To enable
 // this option, call setPrintTestResultsLazily() before running any tests.
 var _lazyTestResults; // Set by setPrintTestResultsLazily().
 var _lazyDescription; // Set by description() after setPrintTestResultsLazily().
 
 // svg/dynamic-updates tests set enablePixelTesting=true, as we want to dump text + pixel results
 if (self.testRunner) {
     if (self.enablePixelTesting)
         testRunner.dumpAsTextWithPixelResults();
     else
         testRunner.dumpAsText();
 }
 
 var isJsTest = true;
 
 var description, debug, successfullyParsed, getOrCreateTestElement;
 
-var expectingError; // set by shouldHaveError()
+var expectingError; // set by expectError()
 var expectedErrorMessage; // set by onerror when expectingError is true
 var unexpectedErrorMessage; // set by onerror when expectingError is not true
 
 (function() {
 
     getOrCreateTestElement = function(id, tagName)
     {
         var element = document.getElementById(id);
         if (element)
             return element;
@@ skipping 82 matching lines @@
         window.addEventListener('DOMContentLoaded', handleTestFinished, false);
         insertStyleSheet();
     }
 
     if (!self.isOnErrorTest) {
         self.onerror = function(message)
         {
             if (self.expectingError) {
                 self.expectedErrorMessage = message;
                 self.expectingError = false;
-                return;
+                // In workers, consume expected error so window doesn't fail the test.
+                return isWorker();
             }
             self.unexpectedErrorMessage = message;
             if (self.jsTestIsAsync) {
                 self.testFailed("Unexpected error: " + message);
                 finishJSTest();
             }
         };
     }
 })();
 
@@ skipping 575 matching lines @@
 
         testPassed(a + " is equivalent to Date.now().");
         return;
     }
     testFailed(a + " cannot be tested against the current time. The clock is going backwards too often.");
 }
 
 function expectError()
 {
     if (expectingError) {
-        testFailed("shouldHaveError() called twice before an error occurred!");
+        testFailed("expectError() called twice before an error occurred!");
     }
     expectingError = true;
 }
 
 function shouldHaveHadError(message)
 {
     if (expectingError) {
         testFailed("No error thrown between expectError() and shouldHaveHadError()");
         return;
     }
 
     if (expectedErrorMessage) {
         if (!message)
             testPassed("Got expected error");
         else if (expectedErrorMessage.indexOf(message) !== -1)
             testPassed("Got expected error: '" + message + "'");
         else
             testFailed("Unexpected error '" + message + "'");
         expectedErrorMessage = undefined;
         return;
     }
 
     testFailed("expectError() not called before shouldHaveHadError()");
 }
 
+// Waits for the global 'onerror' handler to fire, verifies the
+// message with a regex, then calls another function. e.g.
+// waitForError(/AbortError/, nextTestCase);
+function waitForError(regex, continuation)
+{
+    var original_onerror = self.onerror;
+    self.onerror = function(message) {
+        self.onerror = original_onerror;
+        if (regex.test(message))
+            testPassed("Got expected error: '" + message + "'");
+        else
+            testFailed("Unexpected error '" + message + "', expected: " + String(regex));
+        continuation();
+    };
+}
+
 // With Oilpan tests that rely on garbage collection need to go through
 // the event loop in order to get precise garbage collections. Oilpan
 // uses conservative stack scanning when not at the event loop and that
 // can artificially keep objects alive. Therefore, tests that need to check
 // that something is dead need to use this asynchronous collectGarbage
 // function.
 function asyncGC(callback) {
     var documentsBefore = window.internals.numberOfLiveDocuments();
     GCController.collectAll();
     // FIXME: we need a better way of waiting for chromium events to happen
@@ skipping 149 matching lines @@
     testPassed = function(msg) {
         workerPort.postMessage('PASS:' + msg);
     };
     finishJSTest = function() {
         workerPort.postMessage('DONE:');
     };
     debug = function(msg) {
         workerPort.postMessage(msg);
     };
 }