[DevTools] Report unhandled exceptions and promise rejections through Runtime.

third_party/WebKit/Source/platform/v8_inspector/V8ConsoleMessage.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/v8_inspector/V8ConsoleMessage.h"
 
 #include "platform/v8_inspector/InspectedContext.h"
 #include "platform/v8_inspector/V8ConsoleAgentImpl.h"
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 #include "platform/v8_inspector/V8InspectorSessionImpl.h"
+#include "platform/v8_inspector/V8RuntimeAgentImpl.h"
 #include "platform/v8_inspector/V8StackTraceImpl.h"
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8DebuggerClient.h"
 
 namespace blink {
 
 namespace {
 
 String messageSourceValue(MessageSource source)
 {
@@ skipping 33 matching lines @@
 }
 
 String messageLevelValue(MessageLevel level)
 {
     switch (level) {
     case DebugMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Debug;
     case LogMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Log;
     case WarningMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Warning;
     case ErrorMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Error;
     case InfoMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::Info;
-    case RevokedErrorMessageLevel: return protocol::Console::ConsoleMessage::LevelEnum::RevokedError;
     }
     return protocol::Console::ConsoleMessage::LevelEnum::Log;
 }
 
 const unsigned maxConsoleMessageCount = 1000;
 const unsigned maxArrayItemsLimit = 10000;
 const unsigned maxStackDepthLimit = 32;
 
 class V8ValueStringBuilder {
 public:
@@ skipping 116 matching lines @@
     uint32_t m_arrayLimit;
     v8::Isolate* m_isolate;
     String16Builder m_builder;
     Vector<v8::Local<v8::Array>> m_visitedArrays;
     v8::TryCatch m_tryCatch;
 };
 
 } // namespace
 
 V8ConsoleMessage::V8ConsoleMessage(
-    double timestampMS,
+    double timestamp,
     MessageSource source,
     MessageLevel level,
     const String16& message,
     const String16& url,
     unsigned lineNumber,
     unsigned columnNumber,
     std::unique_ptr<V8StackTrace> stackTrace,
     int scriptId,
     const String16& requestIdentifier)
-    : m_timestamp(timestampMS / 1000.0)
+    : m_origin(V8MessageOrigin::kConsole)
+    , m_timestamp(timestamp)
     , m_source(source)
     , m_level(level)
     , m_message(message)
     , m_url(url)
     , m_lineNumber(lineNumber)
     , m_columnNumber(columnNumber)
     , m_stackTrace(std::move(stackTrace))
     , m_scriptId(scriptId)
     , m_requestIdentifier(requestIdentifier)
     , m_contextId(0)
     , m_type(LogMessageType)
-    , m_messageId(0)
-    , m_relatedMessageId(0)
+    , m_exceptionId(0)
+    , m_revokedExceptionId(0)
 {
 }
 
 V8ConsoleMessage::~V8ConsoleMessage()
 {
 }
 
-std::unique_ptr<protocol::Console::ConsoleMessage> V8ConsoleMessage::buildInspectorObject(V8InspectorSessionImpl* session, bool generatePreview) const
+void V8ConsoleMessage::reportToFrontend(protocol::Console::Frontend* frontend, V8InspectorSessionImpl* session, bool generatePreview) const
 {
+    DCHECK_EQ(V8MessageOrigin::kConsole, m_origin);
     std::unique_ptr<protocol::Console::ConsoleMessage> result =
         protocol::Console::ConsoleMessage::create()
         .setSource(messageSourceValue(m_source))
         .setLevel(messageLevelValue(m_level))
         .setText(m_message)
-        .setTimestamp(m_timestamp)
+        .setTimestamp(m_timestamp / 1000) // TODO(dgozman): migrate this to milliseconds.
         .build();
     result->setType(messageTypeValue(m_type));
     result->setLine(static_cast<int>(m_lineNumber));
     result->setColumn(static_cast<int>(m_columnNumber));
     if (m_scriptId)
         result->setScriptId(String::number(m_scriptId));
     result->setUrl(m_url);
     if (m_source == NetworkMessageSource && !m_requestIdentifier.isEmpty())
         result->setNetworkRequestId(m_requestIdentifier);
     if (m_contextId)
         result->setExecutionContextId(m_contextId);
-    appendArguments(result.get(), session, generatePreview);
+    std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> args = wrapArguments(session, generatePreview);
+    if (args)
+        result->setParameters(std::move(args));
     if (m_stackTrace)
         result->setStack(m_stackTrace->buildInspectorObject());
-    if (m_messageId)
-        result->setMessageId(m_messageId);
-    if (m_relatedMessageId)
-        result->setRelatedMessageId(m_relatedMessageId);
-    return result;
+    frontend->messageAdded(std::move(result));
 }
 
-void V8ConsoleMessage::appendArguments(protocol::Console::ConsoleMessage* result, V8InspectorSessionImpl* session, bool generatePreview) const
+std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> V8ConsoleMessage::wrapArguments(V8InspectorSessionImpl* session, bool generatePreview) const
 {
     if (!m_arguments.size() || !m_contextId)
-        return;
+        return nullptr;
     InspectedContext* inspectedContext = session->debugger()->getContext(session->contextGroupId(), m_contextId);
     if (!inspectedContext)
-        return;
+        return nullptr;
 
     v8::Isolate* isolate = inspectedContext->isolate();
     v8::HandleScope handles(isolate);
     v8::Local<v8::Context> context = inspectedContext->context();
 
     std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> args = protocol::Array<protocol::Runtime::RemoteObject>::create();
     if (m_type == TableMessageType && generatePreview) {
         v8::Local<v8::Value> table = m_arguments[0]->Get(isolate);
         v8::Local<v8::Value> columns = m_arguments.size() > 1 ? m_arguments[1]->Get(isolate) : v8::Local<v8::Value>();
         std::unique_ptr<protocol::Runtime::RemoteObject> wrapped = session->wrapTable(context, table, columns);
         if (wrapped)
             args->addItem(std::move(wrapped));
         else
             args = nullptr;
     } else {
         for (size_t i = 0; i < m_arguments.size(); ++i) {
             std::unique_ptr<protocol::Runtime::RemoteObject> wrapped = session->wrapObject(context, m_arguments[i]->Get(isolate), "console", generatePreview);
             if (!wrapped) {
                 args = nullptr;
                 break;
             }
             args->addItem(std::move(wrapped));
         }
     }
-    if (args)
-        result->setParameters(std::move(args));
+    return args;
+}
+
+void V8ConsoleMessage::reportToFrontend(protocol::Runtime::Frontend* frontend, V8InspectorSessionImpl* session, bool generatePreview) const
+{
+    if (m_origin == V8MessageOrigin::kException) {
+        // TODO(dgozman): unify with InjectedScript::createExceptionDetails.
+        std::unique_ptr<protocol::Runtime::ExceptionDetails> details = protocol::Runtime::ExceptionDetails::create().setText(m_message).build();
+        details->setUrl(m_url);
+        if (m_lineNumber)
+            details->setLineNumber(static_cast<int>(m_lineNumber) - 1);
+        if (m_columnNumber)
+            details->setColumnNumber(static_cast<int>(m_columnNumber) - 1);
+        if (m_scriptId)
+            details->setScriptId(String::number(m_scriptId));
+        if (m_stackTrace)
+            details->setStack(m_stackTrace->buildInspectorObject());
+
+        std::unique_ptr<protocol::Runtime::RemoteObject> exception = wrapException(session, generatePreview);
+
+        if (exception)
+            frontend->exceptionThrown(m_exceptionId, m_timestamp, std::move(details), std::move(exception), m_contextId);
+        else
+            frontend->exceptionThrown(m_exceptionId, m_timestamp, std::move(details));
+        return;
+    }
+    if (m_origin == V8MessageOrigin::kRevokedException) {
+        frontend->exceptionRevoked(m_timestamp, m_message, m_revokedExceptionId);
+        return;
+    }
+    NOTREACHED();
+}
+
+std::unique_ptr<protocol::Runtime::RemoteObject> V8ConsoleMessage::wrapException(V8InspectorSessionImpl* session, bool generatePreview) const
+{
+    if (!m_arguments.size() || !m_contextId)
+        return nullptr;
+    DCHECK_EQ(1u, m_arguments.size());
+    InspectedContext* inspectedContext = session->debugger()->getContext(session->contextGroupId(), m_contextId);
+    if (!inspectedContext)
+        return nullptr;
+
+    v8::Isolate* isolate = inspectedContext->isolate();
+    v8::HandleScope handles(isolate);
+    // TODO(dgozman): should we use different object group?
+    return session->wrapObject(inspectedContext->context(), m_arguments[0]->Get(isolate), "console", generatePreview);
+}
+
+V8MessageOrigin V8ConsoleMessage::origin() const
+{
+    return m_origin;
 }
 
 unsigned V8ConsoleMessage::argumentCount() const
 {
     return m_arguments.size();
 }
 
 MessageType V8ConsoleMessage::type() const
 {
     return m_type;
 }
 
 // static
-std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForConsoleAPI(double timestampMS, MessageType type, MessageLevel level, const String16& messageText, std::vector<v8::Local<v8::Value>>* arguments, std::unique_ptr<V8StackTrace> stackTrace, InspectedContext* context)
+std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForConsoleAPI(double timestamp, MessageType type, MessageLevel level, const String16& messageText, std::vector<v8::Local<v8::Value>>* arguments, std::unique_ptr<V8StackTrace> stackTrace, InspectedContext* context)
 {
     String16 url;
     unsigned lineNumber = 0;
     unsigned columnNumber = 0;
     if (stackTrace && !stackTrace->isEmpty()) {
         url = stackTrace->topSourceURL();
         lineNumber = stackTrace->topLineNumber();
         columnNumber = stackTrace->topColumnNumber();
     }
 
     String16 actualMessage = messageText;
 
     Arguments messageArguments;
     if (arguments && arguments->size()) {
         for (size_t i = 0; i < arguments->size(); ++i)
             messageArguments.push_back(wrapUnique(new v8::Global<v8::Value>(context->isolate(), arguments->at(i))));
         if (actualMessage.isEmpty())
             actualMessage = V8ValueStringBuilder::toString(messageArguments.at(0)->Get(context->isolate()), context->isolate());
     }
 
-    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(timestampMS, ConsoleAPIMessageSource, level, actualMessage, url, lineNumber, columnNumber, std::move(stackTrace), 0 /* scriptId */, String16() /* requestIdentifier */));
+    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(timestamp, ConsoleAPIMessageSource, level, actualMessage, url, lineNumber, columnNumber, std::move(stackTrace), 0 /* scriptId */, String16() /* requestIdentifier */));
     message->m_type = type;
     if (messageArguments.size()) {
         message->m_contextId = context->contextId();
         message->m_arguments.swap(messageArguments);
     }
 
     context->debugger()->client()->messageAddedToConsole(context->contextGroupId(), message->m_source, message->m_level, message->m_message, message->m_url, message->m_lineNumber, message->m_columnNumber, message->m_stackTrace.get());
     return message;
 }
 
+// static
+std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForException(double timestamp, const String16& messageText, const String16& url, unsigned lineNumber, unsigned columnNumber, std::unique_ptr<V8StackTrace> stackTrace, int scriptId, v8::Isolate* isolate, int contextId, v8::Local<v8::Value> exception, unsigned exceptionId)
+{
+    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(timestamp, JSMessageSource, ErrorMessageLevel, messageText, url, lineNumber, columnNumber, std::move(stackTrace), scriptId, String16() /* requestIdentifier */));
+    message->m_exceptionId = exceptionId;
+    message->m_origin = V8MessageOrigin::kException;
+    if (contextId && !exception.IsEmpty()) {
+        message->m_contextId = contextId;
+        message->m_arguments.push_back(wrapUnique(new v8::Global<v8::Value>(isolate, exception)));
+    }
+    return message;
+}
+
+// static
+std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForRevokedException(double timestamp, const String16& messageText, unsigned revokedExceptionId)
+{
+    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(timestamp, JSMessageSource, ErrorMessageLevel, messageText, String16(), 0, 0, nullptr, 0, String16()));
+    message->m_origin = V8MessageOrigin::kRevokedException;
+    message->m_revokedExceptionId = revokedExceptionId;
+    return message;
+}
+
 void V8ConsoleMessage::contextDestroyed(int contextId)
 {
     if (contextId != m_contextId)
         return;
     m_contextId = 0;
     if (m_message.isEmpty())
         m_message = "<message collected>";
     Arguments empty;
     m_arguments.swap(empty);
 }
 
-void V8ConsoleMessage::assignId(unsigned id)
-{
-    m_messageId = id;
-}
-
-void V8ConsoleMessage::assignRelatedId(unsigned id)
-{
-    m_relatedMessageId = id;
-}
-
-void V8ConsoleMessage::addArguments(v8::Isolate* isolate, int contextId, std::vector<v8::Local<v8::Value>>* arguments)
-{
-    if (!arguments || !contextId)
-        return;
-    m_contextId = contextId;
-    for (size_t i = 0; i < arguments->size(); ++i)
-        m_arguments.push_back(wrapUnique(new v8::Global<v8::Value>(isolate, arguments->at(i))));
-}
-
 // ------------------------ V8ConsoleMessageStorage ----------------------------
 
 V8ConsoleMessageStorage::V8ConsoleMessageStorage(V8DebuggerImpl* debugger, int contextGroupId)
     : m_debugger(debugger)
     , m_contextGroupId(contextGroupId)
     , m_expiredCount(0)
 {
 }
 
 V8ConsoleMessageStorage::~V8ConsoleMessageStorage()
 {
     clear();
 }
 
 void V8ConsoleMessageStorage::addMessage(std::unique_ptr<V8ConsoleMessage> message)
 {
     if (message->type() == ClearMessageType)
         clear();
 
     V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId);
-    if (session)
-        session->consoleAgent()->messageAdded(message.get());
+    if (session) {
+        if (message->origin() == V8MessageOrigin::kConsole)
+            session->consoleAgent()->messageAdded(message.get());
+        else
+            session->runtimeAgent()->exceptionMessageAdded(message.get());
+    }
 
     DCHECK(m_messages.size() <= maxConsoleMessageCount);
     if (m_messages.size() == maxConsoleMessageCount) {
         ++m_expiredCount;
         m_messages.pop_front();
     }
     m_messages.push_back(std::move(message));
 }
 
 void V8ConsoleMessageStorage::clear()
 {
     m_messages.clear();
     m_expiredCount = 0;
     V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId);
     if (session) {
         session->consoleAgent()->reset();
         session->releaseObjectGroup("console");
         session->client()->consoleCleared();
     }
 }
 
 void V8ConsoleMessageStorage::contextDestroyed(int contextId)
 {
     for (size_t i = 0; i < m_messages.size(); ++i)
         m_messages[i]->contextDestroyed(contextId);
 }
 
 } // namespace blink