Fire window.onerror for uncaught IndexedDB errors

Source/modules/indexeddb/IDBRequest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 13 matching lines @@
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/indexeddb/IDBRequest.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
+#include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/modules/v8/ToV8ForModules.h"
 #include "bindings/modules/v8/V8BindingForModules.h"
 #include "core/dom/ExecutionContext.h"
+#include "core/events/ErrorEvent.h"
 #include "core/events/EventQueue.h"
+#include "core/inspector/ScriptCallFrame.h"
+#include "core/inspector/ScriptCallStack.h"
 #include "modules/IndexedDBNames.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "modules/indexeddb/IDBValue.h"
 #include "platform/SharedBuffer.h"
 #include "public/platform/WebBlobInfo.h"
 
 using blink::WebIDBCursor;
 
 namespace blink {
 
 IDBRequest* IDBRequest::create(ScriptState* scriptState, IDBAny* source, IDBTransaction* transaction)
 {
     IDBRequest* request = new IDBRequest(scriptState, source, transaction);
     request->suspendIfNeeded();
     // Requests associated with IDBFactory (open/deleteDatabase/getDatabaseNames) are not associated with transactions.
     if (transaction)
         transaction->registerRequest(request);
     return request;
 }
 
 IDBRequest::IDBRequest(ScriptState* scriptState, IDBAny* source, IDBTransaction* transaction)
     : ActiveDOMObject(scriptState->executionContext())
     , m_transaction(transaction)
     , m_scriptState(scriptState)
     , m_source(source)
 {
+    m_creationStack = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture);
+    ASSERT(m_creationStack && m_creationStack->size());
 }
 
 IDBRequest::~IDBRequest()
 {
     ASSERT(m_readyState == DONE || m_readyState == EarlyDeath || !executionContext());
 }
 
 DEFINE_TRACE(IDBRequest)
 {
     visitor->trace(m_transaction);
     visitor->trace(m_source);
     visitor->trace(m_result);
     visitor->trace(m_error);
     visitor->trace(m_enqueuedEvents);
     visitor->trace(m_pendingCursor);
     visitor->trace(m_cursorKey);
     visitor->trace(m_cursorPrimaryKey);
+    visitor->trace(m_creationStack);
     RefCountedGarbageCollectedEventTargetWithInlineData<IDBRequest>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 ScriptValue IDBRequest::result(ExceptionState& exceptionState)
 {
     if (m_readyState != DONE) {
         exceptionState.throwDOMException(InvalidStateError, IDBDatabase::requestNotFinishedErrorMessage);
         return ScriptValue();
     }
@@ skipping 355 matching lines @@
         m_didFireUpgradeNeededEvent = true;
     }
 
     // FIXME: When we allow custom event dispatching, this will probably need to change.
     ASSERT_WITH_MESSAGE(event->type() == EventTypeNames::success || event->type() == EventTypeNames::error || event->type() == EventTypeNames::blocked || event->type() == EventTypeNames::upgradeneeded, "event type was %s", event->type().utf8().data());
     const bool setTransactionActive = m_transaction && (event->type() == EventTypeNames::success || event->type() == EventTypeNames::upgradeneeded || (event->type() == EventTypeNames::error && !m_requestAborted));
 
     if (setTransactionActive)
         m_transaction->setActive(true);
 
-    bool dontPreventDefault = IDBEventDispatcher::dispatch(event.get(), targets);
+    bool shouldPerformDefault = IDBEventDispatcher::dispatch(event.get(), targets);
 
     if (m_transaction) {
         if (m_readyState == DONE)
             m_transaction->unregisterRequest(this);
 
         // Possibly abort the transaction. This must occur after unregistering (so this request
         // doesn't receive a second error) and before deactivating (which might trigger commit).
-        if (event->type() == EventTypeNames::error && dontPreventDefault && !m_requestAborted) {
+        if (event->type() == EventTypeNames::error && shouldPerformDefault && !m_requestAborted) {
             m_transaction->setError(m_error);
             m_transaction->abort(IGNORE_EXCEPTION);
         }
 
         // If this was the last request in the transaction's list, it may commit here.
         if (setTransactionActive)
             m_transaction->setActive(false);
     }
 
     if (cursorToNotify)
         cursorToNotify->postSuccessHandlerCallback();
 
     // An upgradeneeded event will always be followed by a success or error event, so must
     // be kept alive.
     if (m_readyState == DONE && event->type() != EventTypeNames::upgradeneeded)
         m_hasPendingActivity = false;
 
-    return dontPreventDefault;
+    // Fire window.onerror (or the equivalent for workers) for errors that were not prevented.
+    if (!m_preventPropagation && shouldPerformDefault && event->type() == EventTypeNames::error && m_creationStack.get() && m_creationStack->size()) {
+        const ScriptCallFrame& frame = m_creationStack->at(0);
+        const AccessControlStatus corsStatus = NotSharableCrossOrigin;
+        RefPtrWillBeRawPtr<ErrorEvent> errorEvent;
+        if (executionContext()->shouldSanitizeScriptError(frame.sourceURL(), corsStatus))
+            errorEvent = ErrorEvent::createSanitizedError(&m_scriptState->world());
+        else
+            errorEvent = ErrorEvent::create(m_error->toStringForConsole(), frame.sourceURL(), frame.lineNumber(), frame.columnNumber(), &m_scriptState->world());
+        executionContext()->reportException(errorEvent, frame.scriptId().toInt(), m_creationStack, corsStatus);
+    }
+
+    return shouldPerformDefault;
 }
 
 void IDBRequest::uncaughtExceptionInEventHandler()
 {
     if (m_transaction && !m_requestAborted) {
         m_transaction->setError(DOMError::create(AbortError, "Uncaught exception in event handler."));
         m_transaction->abort(IGNORE_EXCEPTION);
     }
 }
 
@@ skipping 33 matching lines @@
 
 void IDBRequest::dequeueEvent(Event* event)
 {
     for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
         if (m_enqueuedEvents[i].get() == event)
             m_enqueuedEvents.remove(i);
     }
 }
 
 } // namespace blink