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 14 matching lines @@
  * (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/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "bindings/v8/IDBBindingUtilities.h"
+#include "bindings/v8/ScriptCallStackFactory.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/EventQueue.h"
+#include "core/inspector/ScriptCallFrame.h"
+#include "core/inspector/ScriptCallStack.h"
 #include "modules/indexeddb/IDBCursorWithValue.h"
 #include "modules/indexeddb/IDBDatabase.h"
 #include "modules/indexeddb/IDBEventDispatcher.h"
 #include "modules/indexeddb/IDBTracing.h"
 #include "platform/SharedBuffer.h"
 #include "public/platform/WebBlobInfo.h"
 
 using blink::WebIDBCursor;
 
 namespace WebCore {
@@ skipping 18 matching lines @@
     , m_source(source)
     , m_hasPendingActivity(true)
     , m_cursorType(IndexedDB::CursorKeyAndValue)
     , m_cursorDirection(blink::WebIDBCursor::Next)
     , m_pendingCursor(nullptr)
     , m_didFireUpgradeNeededEvent(false)
     , m_preventPropagation(false)
     , m_resultDirty(true)
 {
     ScriptWrappable::init(this);
+
+    if (scriptState->isolate()->InContext())
+        m_creationStackTrace = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);

[cmumford, 2014/06/18 21:32:36]

I see that in some places in Blink we don't allow (which is the default) an
empty call stack. What's the rationale to allow it here?

Also, what do you think the performance impact will be to capturing this call
stack every time?

[jsbell, 2014/06/18 22:28:46]

Can you give me an example? I must be missing something in my search.
No idea. :)

I do know that (1) Firefox manages to do it, and (2) it's something we'll want
for debugging Promises, so if it's too slow we need to solve that.

[cmumford, 2014/06/23 15:58:04]

createScriptCallStackForConsole (used in a few places), and
Source/core/frame/csp/ContentSecurityPolicy.cpp:574. But all others allow an
empty stack.

[jsbell, 2014/07/02 19:40:41]

Thanks. It appears (ScriptCallStackFactory.cpp:79) that disallowing an empty
call stack synthesizes a dummy entry in the case where a stack can't be
obtained. While that's not terribly helpful (i.e. you won't get the line
number), I guess it's better to get the onerror than not.

From the comments, the scenario appears to be something like
[0].map(store.add.bind(store))

I'll flip it, and assert that the stack is non-empty.

[jsbell, 2014/07/02 19:59:13]

And FYI, I tried testing w/:

[0, 0].forEach(store.add.bind(store, 0, 0));

which should mean a native call (forEach) into a native call (the bound
store.add) but I'm still getting a valid stack in that case.

 }
 
 IDBRequest::~IDBRequest()
 {
     ASSERT(m_readyState == DONE || m_readyState == EarlyDeath || !executionContext());
     handleBlobAcks();
 }
 
 void IDBRequest::trace(Visitor* visitor)
 {
@@ skipping 401 matching lines @@
     }
 
     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;
 
+    if (!m_preventPropagation && dontPreventDefault && event->type() == EventTypeNames::error && m_creationStackTrace && m_creationStackTrace->size()) {

[ericu, 2014/06/19 00:54:06]

Under what circumstances would we not have a stack trace, or would have one, but
of zero size?  Is there any value to reporting the exception even without the
stack trace?

[jsbell, 2014/06/19 17:44:38]

I believe recent test refactors ensure our unit tests always have an isolate
when IDBRequests are created so I can simplify the test and assert
m_creationStackTrace is non-null.

The stack should only be zero size in unit tests, so we don't need to report
errors if we can't get a stack frame.

+        const ScriptCallFrame& frame = m_creationStackTrace->at(0);
+        const AccessControlStatus corsStatus = NotSharableCrossOrigin;
+        RefPtr<ErrorEvent> errorEvent;
+        if (executionContext()->shouldSanitizeScriptError(frame.sourceURL(), corsStatus)) {
+            errorEvent = ErrorEvent::createSanitizedError(&m_scriptState->world());
+        } else {
+            String message = m_error->name() + ": " + m_error->message();
+            errorEvent = ErrorEvent::create(message, frame.sourceURL(), frame.lineNumber(), frame.columnNumber(), &m_scriptState->world());
+        }
+        executionContext()->reportException(errorEvent, m_creationStackTrace, corsStatus);
+    }
+
     return dontPreventDefault;
 }
 
 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 34 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 WebCore