[DevTools] Fill ExceptionDetails with more details, unify usage across protocol.

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

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 32 matching lines @@
 #include "platform/v8_inspector/V8StringUtil.h"
 #include "platform/v8_inspector/public/V8InspectorClient.h"
 
 namespace v8_inspector {
 
 namespace V8RuntimeAgentImplState {
 static const char customObjectFormatterEnabled[] = "customObjectFormatterEnabled";
 static const char runtimeEnabled[] = "runtimeEnabled";
 };
 
-using protocol::Runtime::ExceptionDetails;
 using protocol::Runtime::RemoteObject;
 
 static bool hasInternalError(ErrorString* errorString, bool hasError)
 {
     if (hasError)
         *errorString = "Internal error";
     return hasError;
 }
 
 namespace {
@@ skipping 35 matching lines @@
         v8::Local<v8::Value> value = info.Length() > 0 ? info[0] : v8::Local<v8::Value>::Cast(v8::Undefined(info.GetIsolate()));
         handler->m_callback->sendSuccess(handler->wrapObject(value), Maybe<protocol::Runtime::ExceptionDetails>());
     }
 
     static void catchCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
     {
         ProtocolPromiseHandler<Callback>* handler = static_cast<ProtocolPromiseHandler<Callback>*>(info.Data().As<v8::External>()->Value());
         DCHECK(handler);
         v8::Local<v8::Value> value = info.Length() > 0 ? info[0] : v8::Local<v8::Value>::Cast(v8::Undefined(info.GetIsolate()));
 
-        std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails;
         std::unique_ptr<V8StackTraceImpl> stack = handler->m_inspector->debugger()->captureStackTrace(true);
-        if (stack) {
-            exceptionDetails = protocol::Runtime::ExceptionDetails::create()
-                .setText("Promise was rejected")
-                .setLineNumber(!stack->isEmpty() ? stack->topLineNumber() : 0)
-                .setColumnNumber(!stack->isEmpty() ? stack->topColumnNumber() : 0)
-                .setScriptId(!stack->isEmpty() ? stack->topScriptId() : String16())
-                .setStackTrace(stack->buildInspectorObjectImpl())
-                .build();
-        }
+        std::unique_ptr<protocol::Runtime::ExceptionDetails> exceptionDetails = protocol::Runtime::ExceptionDetails::create()
+            .setExceptionId(handler->m_inspector->nextExceptionId())
+            .setText("Uncaught (in promise)")
+            .setLineNumber(stack && !stack->isEmpty() ? stack->topLineNumber() : 0)
+            .setColumnNumber(stack && !stack->isEmpty() ? stack->topColumnNumber() : 0)
+            .setException(handler->wrapObject(value))
+            .build();
+        if (stack)
+            exceptionDetails->setStackTrace(stack->buildInspectorObjectImpl());
+        if (stack && !stack->isEmpty())
+            exceptionDetails->setScriptId(stack->topScriptId());
         handler->m_callback->sendSuccess(handler->wrapObject(value), std::move(exceptionDetails));
     }
 
     ProtocolPromiseHandler(V8InspectorImpl* inspector, int contextGroupId, int executionContextId, const String16& objectGroup, bool returnByValue, bool generatePreview, std::unique_ptr<Callback> callback)
         : m_inspector(inspector)
         , m_contextGroupId(contextGroupId)
         , m_executionContextId(executionContextId)
         , m_objectGroup(objectGroup)
         , m_returnByValue(returnByValue)
         , m_generatePreview(generatePreview)
@@ skipping 274 matching lines @@
 }
 
 void V8RuntimeAgentImpl::getProperties(
     ErrorString* errorString,
     const String16& objectId,
     const Maybe<bool>& ownProperties,
     const Maybe<bool>& accessorPropertiesOnly,
     const Maybe<bool>& generatePreview,
     std::unique_ptr<protocol::Array<protocol::Runtime::PropertyDescriptor>>* result,
     Maybe<protocol::Array<protocol::Runtime::InternalPropertyDescriptor>>* internalProperties,
-    Maybe<ExceptionDetails>* exceptionDetails)
+    Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     using protocol::Runtime::InternalPropertyDescriptor;
 
     InjectedScript::ObjectScope scope(errorString, m_inspector, m_session->contextGroupId(), objectId);
     if (!scope.initialize())
         return;
 
     scope.ignoreExceptionsAndMuteConsole();
     if (!scope.object()->IsObject()) {
         *errorString = "Value with given id is not an object";
@@ skipping 56 matching lines @@
     V8ConsoleMessageStorage* storage = m_inspector->ensureConsoleMessageStorage(m_session->contextGroupId());
     storage->clear();
 }
 
 void V8RuntimeAgentImpl::compileScript(ErrorString* errorString,
     const String16& expression,
     const String16& sourceURL,
     bool persistScript,
     const Maybe<int>& executionContextId,
     Maybe<String16>* scriptId,
-    Maybe<ExceptionDetails>* exceptionDetails)
+    Maybe<protocol::Runtime::ExceptionDetails>* exceptionDetails)
 {
     if (!m_enabled) {
         *errorString = "Runtime agent is not enabled";
         return;
     }
     int contextId = ensureContext(errorString, m_inspector, m_session->contextGroupId(), executionContextId);
     if (!errorString->isEmpty())
         return;
     InjectedScript::ContextScope scope(errorString, m_inspector, m_session->contextGroupId(), contextId);
     if (!scope.initialize())
         return;
 
     if (!persistScript)
         m_inspector->debugger()->muteScriptParsedEvents();
     v8::Local<v8::Script> script = m_inspector->compileScript(scope.context(), toV8String(m_inspector->isolate(), expression), sourceURL, false);
     if (!persistScript)
         m_inspector->debugger()->unmuteScriptParsedEvents();
     if (script.IsEmpty()) {
-        v8::Local<v8::Message> message = scope.tryCatch().Message();
-        if (!message.IsEmpty())
-            *exceptionDetails = scope.injectedScript()->createExceptionDetails(message);
+        if (scope.tryCatch().HasCaught())
+            *exceptionDetails = scope.injectedScript()->createExceptionDetails(errorString, scope.tryCatch(), String16(), false);
         else
             *errorString = "Script compilation failed";
         return;
     }
 
     if (!persistScript)
         return;
 
     String16 scriptValueId = String16::fromInteger(script->GetUnboundScript()->GetId());
     std::unique_ptr<v8::Global<v8::Script>> global(new v8::Global<v8::Script>(m_inspector->isolate(), script));
@@ skipping 156 matching lines @@
         reportMessage(message, true);
 }
 
 void V8RuntimeAgentImpl::reportMessage(V8ConsoleMessage* message, bool generatePreview)
 {
     message->reportToFrontend(&m_frontend, m_session, generatePreview);
     m_frontend.flush();
 }
 
 } // namespace v8_inspector