Use SourceLocation when reporting runtime exceptions.

third_party/WebKit/Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 10 matching lines @@
  * 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 "bindings/core/v8/V8Initializer.h"
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "bindings/core/v8/RejectedPromises.h"
 #include "bindings/core/v8/RetainedDOMInfo.h"
-#include "bindings/core/v8/ScriptCallStack.h"
 #include "bindings/core/v8/ScriptController.h"
 #include "bindings/core/v8/ScriptValue.h"
+#include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8ErrorEvent.h"
 #include "bindings/core/v8/V8ErrorHandler.h"
 #include "bindings/core/v8/V8GCController.h"
 #include "bindings/core/v8/V8History.h"
 #include "bindings/core/v8/V8IdleTaskRunner.h"
 #include "bindings/core/v8/V8Location.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "bindings/core/v8/V8Window.h"
@@ skipping 44 matching lines @@
     return 0;
 }
 
 static void reportFatalErrorInMainThread(const char* location, const char* message)
 {
     int memoryUsageMB = Platform::current()->actualMemoryUsageMB();
     printf("V8 error: %s (%s).  Current memory usage: %d MB\n", message, location, memoryUsageMB);
     CRASH();
 }
 
-static PassRefPtr<ScriptCallStack> extractCallStack(v8::Isolate* isolate, v8::Local<v8::Message> message, int* const scriptId)
-{
-    v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
-    RefPtr<ScriptCallStack> callStack = ScriptCallStack::create(isolate, stackTrace);
-    *scriptId = message->GetScriptOrigin().ScriptID()->Value();
-    if (!stackTrace.IsEmpty() && stackTrace->GetFrameCount() > 0) {
-        int topScriptId = stackTrace->GetFrame(0)->GetScriptId();
-        if (topScriptId == *scriptId)
-            *scriptId = 0;
-    }
-    return callStack.release();
-}
-
-static String extractResourceName(v8::Local<v8::Message> message, const ExecutionContext* context)
-{
-    v8::Local<v8::Value> resourceName = message->GetScriptOrigin().ResourceName();
-    bool shouldUseDocumentURL = context->isDocument() && (resourceName.IsEmpty() || !resourceName->IsString());
-    return shouldUseDocumentURL ? context->url() : toCoreString(resourceName.As<v8::String>());
-}
-
 static String extractMessageForConsole(v8::Isolate* isolate, v8::Local<v8::Value> data)
 {
     if (V8DOMWrapper::isWrapper(isolate, data)) {
         v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(data);
         const WrapperTypeInfo* type = toWrapperTypeInfo(obj);
         if (V8DOMException::wrapperTypeInfo.isSubclass(type)) {
             DOMException* exception = V8DOMException::toImpl(obj);
             if (exception && !exception->messageForConsole().isEmpty())
                 return exception->toStringForConsole();
         }
     }
     return emptyString();
 }
 
-static ErrorEvent* createErrorEventFromMesssage(ScriptState* scriptState, v8::Local<v8::Message> message, String resourceName)
-{
-    String errorMessage = toCoreStringWithNullCheck(message->Get());
-    int lineNumber = 0;
-    int columnNumber = 0;
-    if (v8Call(message->GetLineNumber(scriptState->context()), lineNumber)
-        && v8Call(message->GetStartColumn(scriptState->context()), columnNumber))
-        ++columnNumber;
-    return ErrorEvent::create(errorMessage, resourceName, lineNumber, columnNumber, &scriptState->world());
-}
-
 static void messageHandlerInMainThread(v8::Local<v8::Message> message, v8::Local<v8::Value> data)
 {
     ASSERT(isMainThread());
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
 
     // If called during context initialization, there will be no entered context.
     ScriptState* scriptState = ScriptState::current(isolate);
     if (!scriptState->contextIsValid())
         return;
 
-    int scriptId = 0;
-    RefPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
+    ExecutionContext* context = scriptState->getExecutionContext();
+    OwnPtr<SourceLocation> location = SourceLocation::fromMessage(isolate, message, context);
 
     AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
     if (message->IsOpaque())
         accessControlStatus = OpaqueResource;
     else if (message->IsSharedCrossOrigin())
         accessControlStatus = SharableCrossOrigin;
 
-    ExecutionContext* context = scriptState->getExecutionContext();
-    String resourceName = extractResourceName(message, context);
-    ErrorEvent* event = createErrorEventFromMesssage(scriptState, message, resourceName);
+    ErrorEvent* event = ErrorEvent::create(toCoreStringWithNullCheck(message->Get()), location->url(), location->lineNumber(), location->columnNumber(), &scriptState->world());
 
     String messageForConsole = extractMessageForConsole(isolate, data);
     if (!messageForConsole.isEmpty())
         event->setUnsanitizedMessage("Uncaught " + messageForConsole);
 
     // This method might be called while we're creating a new context. In this case, we
     // avoid storing the exception object, as we can't create a wrapper during context creation.
     // FIXME: Can we even get here during initialization now that we bail out when GetEntered returns an empty handle?
     if (context->isDocument()) {
         LocalFrame* frame = toDocument(context)->frame();
         if (frame && frame->script().existingWindowProxy(scriptState->world())) {
             V8ErrorHandler::storeExceptionOnErrorEventWrapper(scriptState, event, data, scriptState->context()->Global());
         }
     }
 
     if (scriptState->world().isPrivateScriptIsolatedWorld()) {
         // We allow a private script to dispatch error events even in a EventDispatchForbiddenScope scope.
         // Without having this ability, it's hard to debug the private script because syntax errors
         // in the private script are not reported to console (the private script just crashes silently).
         // Allowing error events in private scripts is safe because error events don't propagate to
         // other isolated worlds (which means that the error events won't fire any event listeners
         // in user's scripts).
         EventDispatchForbiddenScope::AllowUserAgentEvents allowUserAgentEvents;
-        context->reportException(event, scriptId, callStack, accessControlStatus);
+        context->reportException(event, std::move(location), accessControlStatus);
     } else {
-        context->reportException(event, scriptId, callStack, accessControlStatus);
+        context->reportException(event, std::move(location), accessControlStatus);
     }
 }
 
 namespace {
 
 static RejectedPromises& rejectedPromisesOnMainThread()
 {
     ASSERT(isMainThread());
     DEFINE_STATIC_LOCAL(RefPtr<RejectedPromises>, rejectedPromises, (RejectedPromises::create()));
     return *rejectedPromises;
 }
 
 } // namespace
 
 void V8Initializer::reportRejectedPromisesOnMainThread()
 {
     rejectedPromisesOnMainThread().processQueue();
 }
 
-static void promiseRejectHandler(v8::PromiseRejectMessage data, RejectedPromises& rejectedPromises, const String& fallbackResourceName)
+static void promiseRejectHandler(v8::PromiseRejectMessage data, RejectedPromises& rejectedPromises, ScriptState* scriptState)
 {
     if (data.GetEvent() == v8::kPromiseHandlerAddedAfterReject) {
         rejectedPromises.handlerAdded(data);
         return;
     }
 
     ASSERT(data.GetEvent() == v8::kPromiseRejectWithNoHandler);
 
     v8::Local<v8::Promise> promise = data.GetPromise();
     v8::Isolate* isolate = promise->GetIsolate();
-    ScriptState* scriptState = ScriptState::current(isolate);
+    ExecutionContext* context = scriptState->getExecutionContext();
 
     v8::Local<v8::Value> exception = data.GetValue();
     if (V8DOMWrapper::isWrapper(isolate, exception)) {
         // Try to get the stack & location from a wrapped exception object (e.g. DOMException).
         ASSERT(exception->IsObject());
         v8::Local<v8::Object> obj = v8::Local<v8::Object>::Cast(exception);
         v8::Local<v8::Value> error = V8HiddenValue::getHiddenValue(scriptState, obj, V8HiddenValue::error(isolate));
         if (!error.IsEmpty())
             exception = error;
     }
 
-    int scriptId = 0;
-    int lineNumber = 0;
-    int columnNumber = 0;
-    String resourceName = fallbackResourceName;
     String errorMessage;
     AccessControlStatus corsStatus = NotSharableCrossOrigin;
-    RefPtr<ScriptCallStack> callStack;
+    OwnPtr<SourceLocation> location;
 
     v8::Local<v8::Message> message = v8::Exception::CreateMessage(isolate, exception);
     if (!message.IsEmpty()) {
-        V8StringResource<> v8ResourceName(message->GetScriptOrigin().ResourceName());
-        if (v8ResourceName.prepare())
-            resourceName = v8ResourceName;
-        scriptId = message->GetScriptOrigin().ScriptID()->Value();
-        if (v8Call(message->GetLineNumber(scriptState->context()), lineNumber)
-            && v8Call(message->GetStartColumn(scriptState->context()), columnNumber))
-            ++columnNumber;
         // message->Get() can be empty here. https://crbug.com/450330
         errorMessage = toCoreStringWithNullCheck(message->Get());
-        callStack = extractCallStack(isolate, message, &scriptId);
+        location = SourceLocation::fromMessage(isolate, message, context);
         if (message->IsSharedCrossOrigin())
             corsStatus = SharableCrossOrigin;
+    } else {
+        location = SourceLocation::create(context->url().getString(), 0, 0, nullptr);
     }
 
     String messageForConsole = extractMessageForConsole(isolate, data.GetValue());
     if (!messageForConsole.isEmpty())
         errorMessage = "Uncaught " + messageForConsole;
 
-    rejectedPromises.rejectedWithNoHandler(scriptState, data, errorMessage, resourceName, scriptId, lineNumber, columnNumber, callStack, corsStatus);
+    rejectedPromises.rejectedWithNoHandler(scriptState, data, errorMessage, std::move(location), corsStatus);
 }
 
 static void promiseRejectHandlerInMainThread(v8::PromiseRejectMessage data)
 {
     ASSERT(isMainThread());
 
     v8::Local<v8::Promise> promise = data.GetPromise();
 
     v8::Isolate* isolate = promise->GetIsolate();
 
     // TODO(ikilpatrick): Remove this check, extensions tests that use
     // extensions::ModuleSystemTest incorrectly don't have a valid script state.
     LocalDOMWindow* window = currentDOMWindow(isolate);
     if (!window || !window->isCurrentlyDisplayedInFrame())
         return;
 
     // Bail out if called during context initialization.
     ScriptState* scriptState = ScriptState::current(isolate);
     if (!scriptState->contextIsValid())
         return;
 
-    promiseRejectHandler(data, rejectedPromisesOnMainThread(), scriptState->getExecutionContext()->url());
+    promiseRejectHandler(data, rejectedPromisesOnMainThread(), scriptState);
 }
 
 static void promiseRejectHandlerInWorker(v8::PromiseRejectMessage data)
 {
     v8::Local<v8::Promise> promise = data.GetPromise();
 
     // Bail out if called during context initialization.
     v8::Isolate* isolate = promise->GetIsolate();
     ScriptState* scriptState = ScriptState::current(isolate);
     if (!scriptState->contextIsValid())
         return;
 
     ExecutionContext* executionContext = scriptState->getExecutionContext();
     if (!executionContext)
         return;
 
     ASSERT(executionContext->isWorkerGlobalScope());
     WorkerOrWorkletScriptController* scriptController = toWorkerGlobalScope(executionContext)->scriptController();
     ASSERT(scriptController);
 
-    promiseRejectHandler(data, *scriptController->getRejectedPromises(), String());
+    promiseRejectHandler(data, *scriptController->getRejectedPromises(), scriptState);
 }
 
 static void failedAccessCheckCallbackInMainThread(v8::Local<v8::Object> host, v8::AccessType type, v8::Local<v8::Value> data)
 {
     v8::Isolate* isolate = v8::Isolate::GetCurrent();
     Frame* target = findFrame(isolate, host, data);
     if (!target)
         return;
     DOMWindow* targetWindow = target->domWindow();
 
@@ skipping 118 matching lines @@
     if (!scriptState->contextIsValid())
         return;
 
     // Exceptions that occur in error handler should be ignored since in that case
     // WorkerGlobalScope::reportException will send the exception to the worker object.
     if (perIsolateData->isReportingException())
         return;
 
     perIsolateData->setReportingException(true);
 
-    TOSTRING_VOID(V8StringResource<>, resourceName, message->GetScriptOrigin().ResourceName());
-    ErrorEvent* event = createErrorEventFromMesssage(scriptState, message, resourceName);
-
-    int scriptId = 0;
-    RefPtr<ScriptCallStack> callStack = extractCallStack(isolate, message, &scriptId);
+    ExecutionContext* context = scriptState->getExecutionContext();
+    OwnPtr<SourceLocation> location = SourceLocation::fromMessage(isolate, message, context);
+    ErrorEvent* event = ErrorEvent::create(toCoreStringWithNullCheck(message->Get()), location->url(), location->lineNumber(), location->columnNumber(), &scriptState->world());
 
     AccessControlStatus corsStatus = message->IsSharedCrossOrigin() ? SharableCrossOrigin : NotSharableCrossOrigin;
 
     // If execution termination has been triggered as part of constructing
     // the error event from the v8::Message, quietly leave.
     if (!isolate->IsExecutionTerminating()) {
         V8ErrorHandler::storeExceptionOnErrorEventWrapper(scriptState, event, data, scriptState->context()->Global());
-        scriptState->getExecutionContext()->reportException(event, scriptId, callStack, corsStatus);
+        scriptState->getExecutionContext()->reportException(event, std::move(location), corsStatus);
     }
 
     perIsolateData->setReportingException(false);
 }
 
 static const int kWorkerMaxStackSize = 500 * 1024;
 
 // This function uses a local stack variable to determine the isolate's stack limit. AddressSanitizer may
 // relocate that local variable to a fake stack, which may lead to problems during JavaScript execution.
 // Therefore we disable AddressSanitizer for V8Initializer::initializeWorker().
 NO_SANITIZE_ADDRESS
 void V8Initializer::initializeWorker(v8::Isolate* isolate)
 {
     initializeV8Common(isolate);
 
     isolate->AddMessageListener(messageHandlerInWorker);
     isolate->SetFatalErrorHandler(reportFatalErrorInWorker);
 
     uint32_t here;
     isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here - kWorkerMaxStackSize / sizeof(uint32_t*)));
     isolate->SetPromiseRejectCallback(promiseRejectHandlerInWorker);
 }
 
 } // namespace blink