[DevTools] Always send a copy of worker message through the page.

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 12 matching lines @@
     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;
 }
 
 
 String messageTypeValue(MessageType type)
 {
     switch (type) {
     case LogMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Log;
     case ClearMessageType: return protocol::Console::ConsoleMessage::TypeEnum::Clear;
@@ skipping 147 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 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_origin(V8MessageOrigin::kConsole)
+V8ConsoleMessage::V8ConsoleMessage(V8MessageOrigin origin, double timestamp, MessageSource source, MessageLevel level, const String16& message)
+    : m_origin(origin)
     , 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_lineNumber(0)
+    , m_columnNumber(0)
+    , m_scriptId(0)
     , m_contextId(0)
     , m_type(LogMessageType)
     , 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
 {
     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 / 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);
     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_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 99 matching lines @@
     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(timestamp, ConsoleAPIMessageSource, level, actualMessage, url, lineNumber, columnNumber, std::move(stackTrace), 0 /* scriptId */, String16() /* requestIdentifier */));
+    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(timestamp, JSMessageSource, ErrorMessageLevel, messageText, url, lineNumber, columnNumber, std::move(stackTrace), scriptId, String16() /* requestIdentifier */));
+    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;
-    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;
+    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));
+    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);
 }
@@ skipping 45 matching lines @@
     }
 }
 
 void V8ConsoleMessageStorage::contextDestroyed(int contextId)
 {
     for (size_t i = 0; i < m_messages.size(); ++i)
         m_messages[i]->contextDestroyed(contextId);
 }
 
 } // namespace blink