[DevTools] Move browser logging from Console domain to Log domain.

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 {
 
-String16 messageSourceValue(MessageSource source)
-{
-    switch (source) {
-    case XMLMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Xml;
-    case JSMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Javascript;
-    case NetworkMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Network;
-    case ConsoleAPIMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::ConsoleApi;
-    case StorageMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Storage;
-    case AppCacheMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Appcache;
-    case RenderingMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Rendering;
-    case SecurityMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Security;
-    case OtherMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Other;
-    case DeprecationMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Deprecation;
-    case WorkerMessageSource: return protocol::Console::ConsoleMessage::SourceEnum::Worker;
-    }
-    return protocol::Console::ConsoleMessage::SourceEnum::Other;
-}
-
-
 String16 consoleAPITypeValue(ConsoleAPIType type)
 {
     switch (type) {
     case ConsoleAPIType::kLog: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Log;
     case ConsoleAPIType::kDebug: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Debug;
     case ConsoleAPIType::kInfo: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Info;
     case ConsoleAPIType::kError: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Error;
     case ConsoleAPIType::kWarning: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Warning;
     case ConsoleAPIType::kClear: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Clear;
     case ConsoleAPIType::kDir: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Dir;
     case ConsoleAPIType::kDirXML: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Dirxml;
     case ConsoleAPIType::kTable: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Table;
     case ConsoleAPIType::kTrace: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Trace;
     case ConsoleAPIType::kStartGroup: return protocol::Runtime::ConsoleAPICalled::TypeEnum::StartGroup;
     case ConsoleAPIType::kStartGroupCollapsed: return protocol::Runtime::ConsoleAPICalled::TypeEnum::StartGroupCollapsed;
     case ConsoleAPIType::kEndGroup: return protocol::Runtime::ConsoleAPICalled::TypeEnum::EndGroup;
     case ConsoleAPIType::kAssert: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Assert;
     case ConsoleAPIType::kTimeEnd: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Debug;
     case ConsoleAPIType::kCount: return protocol::Runtime::ConsoleAPICalled::TypeEnum::Debug;
     }
     return protocol::Runtime::ConsoleAPICalled::TypeEnum::Log;
 }
 
-String16 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;
-    }
-    return protocol::Console::ConsoleMessage::LevelEnum::Log;
-}
-
 const unsigned maxConsoleMessageCount = 1000;
 const unsigned maxArrayItemsLimit = 10000;
 const unsigned maxStackDepthLimit = 32;
 
 class V8ValueStringBuilder {
 public:
     static String16 toString(v8::Local<v8::Value> value, v8::Isolate* isolate)
     {
         V8ValueStringBuilder builder(isolate);
         if (!builder.append(value))
@@ skipping 113 matching lines @@
 
     uint32_t m_arrayLimit;
     v8::Isolate* m_isolate;
     String16Builder m_builder;
     std::vector<v8::Local<v8::Array>> m_visitedArrays;
     v8::TryCatch m_tryCatch;
 };
 
 } // namespace
 
-V8ConsoleMessage::V8ConsoleMessage(V8MessageOrigin origin, double timestamp, MessageSource source, MessageLevel level, const String16& message)
+V8ConsoleMessage::V8ConsoleMessage(V8MessageOrigin origin, double timestamp, const String16& message)
     : m_origin(origin)
     , m_timestamp(timestamp)
-    , m_source(source)
-    , m_level(level)
     , m_message(message)
     , m_lineNumber(0)
     , m_columnNumber(0)
     , m_scriptId(0)
     , m_contextId(0)
     , m_type(ConsoleAPIType::kLog)
     , m_exceptionId(0)
     , m_revokedExceptionId(0)
 {
 }
 
 V8ConsoleMessage::~V8ConsoleMessage()
 {
 }
 
 void V8ConsoleMessage::setLocation(const String16& url, unsigned lineNumber, unsigned columnNumber, std::unique_ptr<V8StackTrace> stackTrace, int scriptId)
 {
     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
+void V8ConsoleMessage::reportToFrontend(protocol::Console::Frontend* frontend) const
 {
-    DCHECK(m_origin == V8MessageOrigin::kExternalConsole || m_origin == V8MessageOrigin::kConsole);
+    DCHECK(m_origin == V8MessageOrigin::kConsole);
     std::unique_ptr<protocol::Console::ConsoleMessage> result =
         protocol::Console::ConsoleMessage::create()
-        .setSource(messageSourceValue(m_source))
-        .setLevel(messageLevelValue(m_level))
+        .setSource(protocol::Console::ConsoleMessage::SourceEnum::ConsoleApi)
+        .setLevel(protocol::Console::ConsoleMessage::LevelEnum::Log)
         .setText(m_message)
-        .setTimestamp(m_timestamp)
         .build();
     result->setLine(static_cast<int>(m_lineNumber));
     result->setColumn(static_cast<int>(m_columnNumber));
-    if (m_scriptId)
-        result->setScriptId(String16::fromInteger(m_scriptId));
     result->setUrl(m_url);
-    if (m_source == NetworkMessageSource && !m_requestIdentifier.isEmpty())
-        result->setNetworkRequestId(m_requestIdentifier);
-    if (m_contextId)
-        result->setExecutionContextId(m_contextId);
-    if (m_stackTrace)
-        result->setStack(m_stackTrace->buildInspectorObject());
-    if (m_source == WorkerMessageSource && !m_workerId.isEmpty())
-        result->setWorkerId(m_workerId);
     frontend->messageAdded(std::move(result));
 }
 
 std::unique_ptr<protocol::Array<protocol::Runtime::RemoteObject>> V8ConsoleMessage::wrapArguments(V8InspectorSessionImpl* session, bool generatePreview) const
 {
     if (!m_arguments.size() || !m_contextId)
         return nullptr;
     InspectedContext* inspectedContext = session->debugger()->getContext(session->contextGroupId(), m_contextId);
     if (!inspectedContext)
         return nullptr;
@@ skipping 88 matching lines @@
 }
 
 ConsoleAPIType V8ConsoleMessage::type() const
 {
     return m_type;
 }
 
 // static
 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()));
+    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(V8MessageOrigin::kConsole, timestamp, String16()));
     if (stackTrace && !stackTrace->isEmpty()) {
         message->m_url = stackTrace->topSourceURL();
         message->m_lineNumber = stackTrace->topLineNumber();
         message->m_columnNumber = stackTrace->topColumnNumber();
     }
     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))));
@@ skipping 10 matching lines @@
     if (type == ConsoleAPIType::kInfo)
         level = InfoMessageLevel;
     context->debugger()->client()->consoleAPIMessage(context->contextGroupId(), 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));
+    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(V8MessageOrigin::kException, timestamp, 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));
+    std::unique_ptr<V8ConsoleMessage> message = wrapUnique(new V8ConsoleMessage(V8MessageOrigin::kRevokedException, timestamp, 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::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;
     m_contextId = 0;
     if (m_message.isEmpty())
         m_message = "<message collected>";
     Arguments empty;
     m_arguments.swap(empty);
 }
 
 // ------------------------ V8ConsoleMessageStorage ----------------------------
 
 V8ConsoleMessageStorage::V8ConsoleMessageStorage(V8DebuggerImpl* debugger, int contextGroupId)
     : m_debugger(debugger)
     , m_contextGroupId(contextGroupId)
     , m_expiredCount(0)
 {
 }
 
 V8ConsoleMessageStorage::~V8ConsoleMessageStorage()
 {
     clear();
+    notifyClear();
 }
 
 void V8ConsoleMessageStorage::addMessage(std::unique_ptr<V8ConsoleMessage> message)
 {
-    if (message->type() == ConsoleAPIType::kClear)
+    if (message->type() == ConsoleAPIType::kClear) {
         clear();
+        notifyClear();
+    }
 
     V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId);
     if (session) {
-        if (message->origin() == V8MessageOrigin::kExternalConsole || message->origin() == V8MessageOrigin::kConsole)
+        if (message->origin() == V8MessageOrigin::kConsole)
             session->consoleAgent()->messageAdded(message.get());
-        if (message->origin() != V8MessageOrigin::kExternalConsole)
-            session->runtimeAgent()->messageAdded(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) {
+    if (V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId))
         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);
 }
 
+void V8ConsoleMessageStorage::notifyClear()
+{
+    if (V8InspectorSessionImpl* session = m_debugger->sessionForContextGroup(m_contextGroupId))
+        session->client()->consoleCleared();
+}
+
 } // namespace blink