[DevTools] Move Console to v8 inspector.

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

 /*
  * Copyright (c) 2010-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 18 matching lines @@
  */
 
 #include "platform/v8_inspector/V8DebuggerImpl.h"
 
 #include "platform/inspector_protocol/Values.h"
 #include "platform/v8_inspector/Atomics.h"
 #include "platform/v8_inspector/DebuggerScript.h"
 #include "platform/v8_inspector/InspectedContext.h"
 #include "platform/v8_inspector/ScriptBreakpoint.h"
 #include "platform/v8_inspector/V8Compat.h"
+#include "platform/v8_inspector/V8ConsoleAgentImpl.h"
+#include "platform/v8_inspector/V8ConsoleMessage.h"
 #include "platform/v8_inspector/V8DebuggerAgentImpl.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"
 #include <v8-profiler.h>
 
 namespace blink {
 
@@ skipping 21 matching lines @@
 }
 
 std::unique_ptr<V8Debugger> V8Debugger::create(v8::Isolate* isolate, V8DebuggerClient* client)
 {
     return wrapUnique(new V8DebuggerImpl(isolate, client));
 }
 
 V8DebuggerImpl::V8DebuggerImpl(v8::Isolate* isolate, V8DebuggerClient* client)
     : m_isolate(isolate)
     , m_client(client)
+    , m_capturingStackTracesCount(0)
+    , m_muteConsoleCount(0)
+    , m_lastConsoleMessageId(0)
     , m_enabledAgentsCount(0)
     , m_breakpointsActivated(true)
     , m_runningNestedMessageLoop(false)
 {
 }
 
 V8DebuggerImpl::~V8DebuggerImpl()
 {
 }
 
@@ skipping 13 matching lines @@
     m_debuggerScript.Reset();
     m_debuggerContext.Reset();
     v8::Debug::SetDebugEventListener(m_isolate, nullptr);
 }
 
 bool V8DebuggerImpl::enabled() const
 {
     return !m_debuggerScript.IsEmpty();
 }
 
-int V8Debugger::contextId(v8::Local<v8::Context> context)
+int V8DebuggerImpl::contextId(v8::Local<v8::Context> context)
 {
     v8::Local<v8::Value> data = context->GetEmbedderData(static_cast<int>(v8::Context::kDebugIdIndex));
     if (data.IsEmpty() || !data->IsString())
         return 0;
     String16 dataString = toProtocolString(data.As<v8::String>());
     if (dataString.isEmpty())
         return 0;
     size_t commaPos = dataString.find(",");
     if (commaPos == kNotFound)
         return 0;
@@ skipping 594 matching lines @@
         v8::True(m_isolate), // internal
         toV8String(m_isolate, String16()), // sourceMap
         v8::True(m_isolate)); // opaqueresource
     v8::ScriptCompiler::Source source(code, origin);
     v8::Local<v8::Script> script;
     if (!v8::ScriptCompiler::Compile(context, &source, v8::ScriptCompiler::kNoCompileOptions).ToLocal(&script))
         return v8::Local<v8::Script>();
     return script;
 }
 
+void V8DebuggerImpl::enableStackCapturingIfNeeded()
+{
+    if (!m_capturingStackTracesCount)
+        V8StackTraceImpl::setCaptureStackTraceForUncaughtExceptions(m_isolate, true);
+    ++m_capturingStackTracesCount;
+}
+
+void V8DebuggerImpl::disableStackCapturingIfNeeded()
+{
+    if (!(--m_capturingStackTracesCount))
+        V8StackTraceImpl::setCaptureStackTraceForUncaughtExceptions(m_isolate, false);
+}
+
+V8ConsoleMessageStorage* V8DebuggerImpl::ensureConsoleMessageStorage(int contextGroupId)
+{
+    if (!m_consoleStorageMap.contains(contextGroupId))
+        m_consoleStorageMap.set(contextGroupId, wrapUnique(new V8ConsoleMessageStorage(this, contextGroupId)));
+    return m_consoleStorageMap.get(contextGroupId);
+}
+
 std::unique_ptr<V8StackTrace> V8DebuggerImpl::createStackTrace(v8::Local<v8::StackTrace> stackTrace)
 {
     V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(m_isolate->GetCurrentContext());
-    return V8StackTraceImpl::create(agent, stackTrace, V8StackTrace::maxCallStackSizeToCapture);
+    return V8StackTraceImpl::create(agent, stackTrace, V8StackTraceImpl::maxCallStackSizeToCapture);
 }
 
 std::unique_ptr<V8InspectorSession> V8DebuggerImpl::connect(int contextGroupId, protocol::FrontendChannel* channel, V8InspectorSessionClient* client, const String16* state)
 {
     DCHECK(!m_sessions.contains(contextGroupId));
     std::unique_ptr<V8InspectorSessionImpl> session = V8InspectorSessionImpl::create(this, contextGroupId, channel, client, state);
     m_sessions.set(contextGroupId, session.get());
     return std::move(session);
 }
 
@@ skipping 20 matching lines @@
     std::unique_ptr<InspectedContext> contextOwner(new InspectedContext(this, info, contextId));
     InspectedContext* inspectedContext = contextOwner.get();
     m_contexts.get(info.contextGroupId)->set(contextId, std::move(contextOwner));
 
     if (V8InspectorSessionImpl* session = m_sessions.get(info.contextGroupId))
         session->runtimeAgent()->reportExecutionContextCreated(inspectedContext);
 }
 
 void V8DebuggerImpl::contextDestroyed(v8::Local<v8::Context> context)
 {
-    int contextId = V8Debugger::contextId(context);
+    int contextId = V8DebuggerImpl::contextId(context);
     int contextGroupId = getGroupId(context);
+    if (m_consoleStorageMap.contains(contextGroupId))
+        m_consoleStorageMap.get(contextGroupId)->contextDestroyed(contextId);
+
     if (!m_contexts.contains(contextGroupId) || !m_contexts.get(contextGroupId)->contains(contextId))
         return;
 
     InspectedContext* inspectedContext = m_contexts.get(contextGroupId)->get(contextId);
     if (V8InspectorSessionImpl* session = m_sessions.get(contextGroupId))
         session->runtimeAgent()->reportExecutionContextDestroyed(inspectedContext);
 
     m_contexts.get(contextGroupId)->remove(contextId);
     if (m_contexts.get(contextGroupId)->isEmpty())
         m_contexts.remove(contextGroupId);
 }
 
 void V8DebuggerImpl::resetContextGroup(int contextGroupId)
 {
+    m_consoleStorageMap.remove(contextGroupId);
     if (V8InspectorSessionImpl* session = m_sessions.get(contextGroupId))
         session->reset();
     m_contexts.remove(contextGroupId);
 }
 
 void V8DebuggerImpl::willExecuteScript(v8::Local<v8::Context> context, int scriptId)
 {
     if (V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(context))
         agent->willExecuteScript(scriptId);
 }
 
 void V8DebuggerImpl::didExecuteScript(v8::Local<v8::Context> context)
 {
     if (V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(context))
         agent->didExecuteScript();
 }
 
 void V8DebuggerImpl::idleStarted()
 {
     m_isolate->GetCpuProfiler()->SetIdle(true);
 }
 
 void V8DebuggerImpl::idleFinished()
 {
     m_isolate->GetCpuProfiler()->SetIdle(false);
 }
 
-std::unique_ptr<V8StackTrace> V8DebuggerImpl::captureStackTrace(size_t maxStackSize)
+bool V8DebuggerImpl::addConsoleMessage(int contextGroupId, MessageSource source, MessageLevel level, const String16& message, const String16& url, unsigned lineNumber, unsigned columnNumber, std::unique_ptr<V8StackTrace> stackTrace, int scriptId, const String16& requestIdentifier)
 {
-    V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(m_isolate->GetCurrentContext());
-    return V8StackTraceImpl::capture(agent, maxStackSize);
+    if (m_muteConsoleCount)
+        return false;
+    ensureConsoleMessageStorage(contextGroupId)->addMessage(wrapUnique(new V8ConsoleMessage(m_client->currentTimeMS(), source, level, message, url, lineNumber, columnNumber, std::move(stackTrace), scriptId, requestIdentifier)));
+    return true;
+}
+
+void V8DebuggerImpl::logToConsole(v8::Local<v8::Context> context, const String16& message, protocol::Vector<v8::Local<v8::Value>>* arguments)
+{
+    int contextGroupId = getGroupId(context);
+    if (!contextGroupId || !m_contexts.contains(contextGroupId))
+        return;
+    InspectedContext* inspectedContext = m_contexts.get(contextGroupId)->get(contextId(context));
+    if (!inspectedContext)
+        return;
+    ensureConsoleMessageStorage(contextGroupId)->addMessage(V8ConsoleMessage::createForConsoleAPI(m_client->currentTimeMS(), LogMessageType, LogMessageLevel, message, arguments, captureStackTrace(false), inspectedContext));
+}
+
+unsigned V8DebuggerImpl::promiseRejected(v8::Local<v8::Context> context, const String16& errorMessage, v8::Local<v8::Value> reason, const String16& url, unsigned lineNumber, unsigned columnNumber, std::unique_ptr<V8StackTrace> stackTrace, int scriptId)
+{
+    if (m_muteConsoleCount)
+        return 0;
+    int contextGroupId = getGroupId(context);
+    if (!contextGroupId)
+        return 0;
+
+    const String16 defaultMessage = "Uncaught (in promise)";
+    String16 message = errorMessage;
+    if (message.isEmpty())
+        message = defaultMessage;
+    else if (message.startWith("Uncaught "))
+        message = message.substring(0, 8) + " (in promise)" + message.substring(8);
+
+    m_client->messageAddedToConsole(contextGroupId, JSMessageSource, ErrorMessageLevel, message, url, lineNumber, columnNumber, stackTrace.get());
+    std::unique_ptr<V8ConsoleMessage> consoleMessage = wrapUnique(new V8ConsoleMessage(m_client->currentTimeMS(), JSMessageSource, ErrorMessageLevel, message, url, lineNumber, columnNumber, std::move(stackTrace), scriptId, String16()));
+    unsigned id = ++m_lastConsoleMessageId;
+    consoleMessage->assignId(id);
+
+    protocol::Vector<v8::Local<v8::Value>> arguments;
+    arguments.append(toV8String(m_isolate, defaultMessage));
+    arguments.append(reason);
+    consoleMessage->addArguments(m_isolate, contextId(context), &arguments);
+
+    ensureConsoleMessageStorage(contextGroupId)->addMessage(std::move(consoleMessage));
+    return id;
+}
+
+void V8DebuggerImpl::promiseRejectionRevoked(v8::Local<v8::Context> context, unsigned promiseRejectionId)
+{
+    if (m_muteConsoleCount)
+        return;
+    int contextGroupId = getGroupId(context);
+    if (!contextGroupId)
+        return;
+
+    const String16 message = "Handler added to rejected promise";
+    m_client->messageAddedToConsole(contextGroupId, JSMessageSource, RevokedErrorMessageLevel, message, String16(), 0, 0, nullptr);
+    std::unique_ptr<V8ConsoleMessage> consoleMessage = wrapUnique(new V8ConsoleMessage(m_client->currentTimeMS(), JSMessageSource, RevokedErrorMessageLevel, message, String16(), 0, 0, nullptr, 0, String16()));
+    consoleMessage->assignRelatedId(promiseRejectionId);
+    ensureConsoleMessageStorage(contextGroupId)->addMessage(std::move(consoleMessage));
+}
+
+protocol::Vector<unsigned> V8DebuggerImpl::consoleMessageArgumentCounts(int contextGroupId)
+{
+    if (!m_consoleStorageMap.contains(contextGroupId))
+        return protocol::Vector<unsigned>();
+    return m_consoleStorageMap.get(contextGroupId)->consoleMessageArgumentCounts();
+}
+
+std::unique_ptr<V8StackTrace> V8DebuggerImpl::captureStackTrace(bool fullStack)
+{
+    if (!m_isolate->InContext())
+        return nullptr;
+
+    v8::HandleScope handles(m_isolate);
+    v8::Local<v8::Context> context = m_isolate->GetCurrentContext();
+    int contextGroupId = getGroupId(context);
+    if (!contextGroupId)
+        return nullptr;
+
+    V8InspectorSessionImpl* session = m_sessions.get(contextGroupId);
+    size_t stackSize = fullStack ? V8StackTraceImpl::maxCallStackSizeToCapture : 1;
+    if (session && session->consoleAgent()->enabled())
+        stackSize = V8StackTraceImpl::maxCallStackSizeToCapture;
+
+    V8DebuggerAgentImpl* agent = findEnabledDebuggerAgent(context);
+    return V8StackTraceImpl::capture(agent, stackSize);
 }
 
 v8::Local<v8::Context> V8DebuggerImpl::regexContext()
 {
     if (m_regexContext.IsEmpty())
         m_regexContext.Reset(m_isolate, v8::Context::New(m_isolate));
     return m_regexContext.Get(m_isolate);
 }
 
 void V8DebuggerImpl::discardInspectedContext(int contextGroupId, int contextId)
@@ skipping 11 matching lines @@
         return nullptr;
     return m_contexts.get(contextGroupId);
 }
 
 V8InspectorSessionImpl* V8DebuggerImpl::sessionForContextGroup(int contextGroupId)
 {
     return contextGroupId ? m_sessions.get(contextGroupId) : nullptr;
 }
 
 } // namespace blink