[DevTools] Report console API calls 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"
@@ skipping 21 matching lines @@
     case DeprecationMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Deprecation;
     case WorkerMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Worker;
     }
     return protocol::Console::ConsoleMessage::SourceEnum::Other;
 }
 
 
 String consoleAPITypeValue(ConsoleAPIType type)
 {
     switch (type) {
-    case ConsoleAPIType::kLog: return protocol::Console::ConsoleMessage::TypeEnum::Log;
-    case ConsoleAPIType::kClear: return protocol::Console::ConsoleMessage::TypeEnum::Clear;
-    case ConsoleAPIType::kDir: return protocol::Console::ConsoleMessage::TypeEnum::Dir;
-    case ConsoleAPIType::kDirXML: return protocol::Console::ConsoleMessage::TypeEnum::Dirxml;
-    case ConsoleAPIType::kTable: return protocol::Console::ConsoleMessage::TypeEnum::Table;
-    case ConsoleAPIType::kTrace: return protocol::Console::ConsoleMessage::TypeEnum::Trace;
-    case ConsoleAPIType::kStartGroup: return protocol::Console::ConsoleMessage::TypeEnum::StartGroup;
-    case ConsoleAPIType::kStartGroupCollapsed: return protocol::Console::ConsoleMessage::TypeEnum::StartGroupCollapsed;
-    case ConsoleAPIType::kEndGroup: return protocol::Console::ConsoleMessage::TypeEnum::EndGroup;
-    case ConsoleAPIType::kAssert: return protocol::Console::ConsoleMessage::TypeEnum::Assert;
-    case ConsoleAPIType::kTimeEnd: return protocol::Console::ConsoleMessage::TypeEnum::Log;
-    case ConsoleAPIType::kCount: return protocol::Console::ConsoleMessage::TypeEnum::Log;
+    case ConsoleAPIType::kLog: return protocol::Runtime::ConsoleAPICall::TypeEnum::Log;
+    case ConsoleAPIType::kDebug: return protocol::Runtime::ConsoleAPICall::TypeEnum::Debug;
+    case ConsoleAPIType::kInfo: return protocol::Runtime::ConsoleAPICall::TypeEnum::Info;
+    case ConsoleAPIType::kError: return protocol::Runtime::ConsoleAPICall::TypeEnum::Error;
+    case ConsoleAPIType::kWarning: return protocol::Runtime::ConsoleAPICall::TypeEnum::Warning;
+    case ConsoleAPIType::kClear: return protocol::Runtime::ConsoleAPICall::TypeEnum::Clear;
+    case ConsoleAPIType::kDir: return protocol::Runtime::ConsoleAPICall::TypeEnum::Dir;
+    case ConsoleAPIType::kDirXML: return protocol::Runtime::ConsoleAPICall::TypeEnum::Dirxml;
+    case ConsoleAPIType::kTable: return protocol::Runtime::ConsoleAPICall::TypeEnum::Table;
+    case ConsoleAPIType::kTrace: return protocol::Runtime::ConsoleAPICall::TypeEnum::Trace;
+    case ConsoleAPIType::kStartGroup: return protocol::Runtime::ConsoleAPICall::TypeEnum::StartGroup;
+    case ConsoleAPIType::kStartGroupCollapsed: return protocol::Runtime::ConsoleAPICall::TypeEnum::StartGroupCollapsed;
+    case ConsoleAPIType::kEndGroup: return protocol::Runtime::ConsoleAPICall::TypeEnum::EndGroup;
+    case ConsoleAPIType::kAssert: return protocol::Runtime::ConsoleAPICall::TypeEnum::Assert;
+    case ConsoleAPIType::kTimeEnd: return protocol::Runtime::ConsoleAPICall::TypeEnum::Debug;
+    case ConsoleAPIType::kCount: return protocol::Runtime::ConsoleAPICall::TypeEnum::Debug;
     }
-    return protocol::Console::ConsoleMessage::TypeEnum::Log;
+    return protocol::Runtime::ConsoleAPICall::TypeEnum::Log;
 }
 
 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;
@@ skipping 156 matching lines @@
 {
     m_url = url;
     m_lineNumber = lineNumber;
     m_columnNumber = columnNumber;
     m_stackTrace = std::move(stackTrace);
     m_scriptId = scriptId;
 }
 
 void V8ConsoleMessage::reportToFrontend(protocol::Console::Frontend* frontend, V8InspectorSessionImpl* session, bool generatePreview) const
 {
-    DCHECK_EQ(V8MessageOrigin::kConsole, m_origin);
+    DCHECK_EQ(V8MessageOrigin::kExternalConsole, 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 / 1000) // TODO(dgozman): migrate this to milliseconds.
         .build();
     result->setType(consoleAPITypeValue(m_type));
     result->setLine(static_cast<int>(m_lineNumber));
     result->setColumn(static_cast<int>(m_columnNumber));
@@ skipping 68 matching lines @@
         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;
     }
+    if (m_origin == V8MessageOrigin::kConsole) {
+        std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> arguments = wrapArguments(session, generatePreview);
+        if (!arguments) {
+            arguments = protocol::Array<protocol::Runtime::RemoteObject>::create();
+            if (!m_message.isEmpty()) {
+                std::unique_ptr<protocol::Runtime::RemoteObject> messageArg = protocol::Runtime::RemoteObject::create().setType(protocol::Runtime::RemoteObject::TypeEnum::String).build();
+                messageArg->setValue(protocol::StringValue::create(m_message));
+                arguments->addItem(std::move(messageArg));
+            }
+        }
+        if (m_stackTrace)
+            frontend->consoleAPICall(m_timestamp, consoleAPITypeValue(m_type), std::move(arguments), m_contextId, m_stackTrace->buildInspectorObject());
+        else
+            frontend->consoleAPICall(m_timestamp, consoleAPITypeValue(m_type), std::move(arguments), m_contextId);
+        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)
@@ skipping 14 matching lines @@
 {
     return m_arguments.size();
 }
 
 ConsoleAPIType V8ConsoleMessage::type() const
 {
     return m_type;
 }
 
 // static
-std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createForConsoleAPI(double timestamp, ConsoleAPIType 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, ConsoleAPIType type, const std::vector<v8::Local<v8::Value>>& arguments, std::unique_ptr<V8StackTrace> stackTrace, InspectedContext* context)
 {
+    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(V8MessageOrigin::kConsole, timestamp, ConsoleAPIMessageSource, LogMessageLevel, String16()));
+    message->m_stackTrace = std::move(stackTrace);
+    message->m_type = type;
+    message->m_contextId = context->contextId();
+    for (size_t i = 0; i < arguments.size(); ++i)
+        message->m_arguments.push_back(wrapUnique(new v8::Global<v8::Value>(context->isolate(), arguments.at(i))));
+    if (arguments.size())
+        message->m_message = V8ValueStringBuilder::toString(arguments[0], context->isolate());
+
+    MessageLevel level = LogMessageLevel;
+    if (type == ConsoleAPIType::kDebug || type == ConsoleAPIType::kCount || type == ConsoleAPIType::kTimeEnd)
+        level = DebugMessageLevel;
+    if (type == ConsoleAPIType::kError || type == ConsoleAPIType::kAssert)
+        level = ErrorMessageLevel;
+    if (type == ConsoleAPIType::kWarning)
+        level = WarningMessageLevel;
+    if (type == ConsoleAPIType::kInfo)
+        level = InfoMessageLevel;
     String16 url;
     unsigned lineNumber = 0;
     unsigned columnNumber = 0;
-    if (stackTrace && !stackTrace->isEmpty()) {
-        url = stackTrace->topSourceURL();
-        lineNumber = stackTrace->topLineNumber();
-        columnNumber = stackTrace->topColumnNumber();
+    if (message->m_stackTrace && !message->m_stackTrace->isEmpty()) {
+        url = message->m_stackTrace->topSourceURL();
+        lineNumber = message->m_stackTrace->topLineNumber();
+        columnNumber = message->m_stackTrace->topColumnNumber();
     }
+    context->debugger()->client()->consoleAPIMessage(context->contextGroupId(), level, message->m_message, url, lineNumber, columnNumber, message->m_stackTrace.get());
 
-    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(V8MessageOrigin::kConsole, timestamp, ConsoleAPIMessageSource, level, actualMessage));
-    message->setLocation(url, lineNumber, columnNumber, std::move(stackTrace), 0);
-    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(V8MessageOrigin::kException, timestamp, JSMessageSource, ErrorMessageLevel, messageText));
     message->setLocation(url, lineNumber, columnNumber, std::move(stackTrace), scriptId);
     message->m_exceptionId = exceptionId;
     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(V8MessageOrigin::kRevokedException, timestamp, JSMessageSource, ErrorMessageLevel, messageText));
     message->m_revokedExceptionId = revokedExceptionId;
     return message;
 }
 
 // static
 std::unique_ptr<V8ConsoleMessage> V8ConsoleMessage::createExternal(double timestamp, MessageSource source, MessageLevel level, const String16& messageText, const String16& url, unsigned lineNumber, unsigned columnNumber, std::unique_ptr<V8StackTrace> stackTrace, int scriptId, const String16& requestIdentifier, const String16& workerId)
 {
-    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(V8MessageOrigin::kConsole, timestamp, source, level, messageText));
+    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(V8MessageOrigin::kExternalConsole, timestamp, source, level, messageText));
     message->setLocation(url, lineNumber, columnNumber, std::move(stackTrace), scriptId);
     message->m_requestIdentifier = requestIdentifier;
     message->m_workerId = workerId;
     return message;
 }
 
 void V8ConsoleMessage::contextDestroyed(int contextId)
 {
     if (contextId != m_contextId)
         return;
@@ skipping 18 matching lines @@
     clear();
 }
 
 void V8ConsoleMessageStorage::addMessage(std::unique_ptr<V8ConsoleMessage> message)
 {
     if (message->type() == ConsoleAPIType::kClear)
         clear();
 
     V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId);
     if (session) {
-        if (message->origin() == V8MessageOrigin::kConsole)
+        if (message->origin() == V8MessageOrigin::kExternalConsole)
             session->consoleAgent()->messageAdded(message.get());
         else
-            session->runtimeAgent()->exceptionMessageAdded(message.get());
+            session->runtimeAgent()->messageAdded(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