[wasm][asm.js] Routing asm.js warnings to the dev console.

third_party/WebKit/Source/bindings/core/v8/V8Initializer.cpp

 /*
  * Copyright (C) 2009 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 30 matching lines @@
 #include "bindings/core/v8/V8Location.h"
 #include "bindings/core/v8/V8PerContextData.h"
 #include "bindings/core/v8/V8PrivateProperty.h"
 #include "bindings/core/v8/V8Window.h"
 #include "bindings/core/v8/WorkerOrWorkletScriptController.h"
 #include "core/dom/Document.h"
 #include "core/fetch/AccessControlStatus.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
+#include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/MainThreadDebugger.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/EventDispatchForbiddenScope.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
 #include "wtf/AddressSanitizer.h"
 #include "wtf/PtrUtil.h"
@@ skipping 50 matching lines @@
     const WrapperTypeInfo* type = toWrapperTypeInfo(obj);
     if (V8DOMException::wrapperTypeInfo.isSubclass(type)) {
       DOMException* exception = V8DOMException::toImpl(obj);
       if (exception && !exception->messageForConsole().isEmpty())
         return exception->toStringForConsole();
     }
   }
   return emptyString();
 }
 
+namespace {
+MessageLevel MessageLevelFromNonFatalErrorLevel(int errorLevel) {
+  MessageLevel level = ErrorMessageLevel;
+  switch (errorLevel) {
+    case v8::Isolate::kMessageLog:
+      level = LogMessageLevel;
+      break;
+    case v8::Isolate::kMessageWarning:
+      level = WarningMessageLevel;
+      break;
+    case v8::Isolate::kMessageDebug:
+      level = DebugMessageLevel;
+      break;
+    case v8::Isolate::kMessageInfo:
+      level = InfoMessageLevel;
+      break;
+    case v8::Isolate::kMessageError:
+      level = InfoMessageLevel;
+      break;
+    default:
+      NOTREACHED();
+  }
+  return level;
+}
+}  // namespace
+
 void V8Initializer::messageHandlerInMainThread(v8::Local<v8::Message> message,
                                                v8::Local<v8::Value> data) {
   ASSERT(isMainThread());
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
 
   if (isolate->GetEnteredContext().IsEmpty())
     return;
 
   // If called during context initialization, there will be no entered context.
   ScriptState* scriptState = ScriptState::current(isolate);
   if (!scriptState->contextIsValid())
     return;
 
   ExecutionContext* context = scriptState->getExecutionContext();
   std::unique_ptr<SourceLocation> location =
       SourceLocation::fromMessage(isolate, message, context);
 
+  if (message->ErrorLevel() != v8::Isolate::kMessageError) {
+    context->addConsoleMessage(ConsoleMessage::create(
+        JSMessageSource,
+        MessageLevelFromNonFatalErrorLevel(message->ErrorLevel()),
+        toCoreStringWithNullCheck(message->Get()), std::move(location)));
+    return;
+  }
+
   AccessControlStatus accessControlStatus = NotSharableCrossOrigin;
   if (message->IsOpaque())
     accessControlStatus = OpaqueResource;
   else if (message->IsSharedCrossOrigin())
     accessControlStatus = SharableCrossOrigin;
 
   ErrorEvent* event =
       ErrorEvent::create(toCoreStringWithNullCheck(message->Get()),
                          std::move(location), &scriptState->world());
 
@@ skipping 219 matching lines @@
                           : gin::IsolateHolder::kStableV8Extras;
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
                                  v8ExtrasMode, &arrayBufferAllocator);
 
   v8::Isolate* isolate = V8PerIsolateData::initialize();
 
   initializeV8Common(isolate);
 
   isolate->SetOOMErrorHandler(reportOOMErrorInMainThread);
   isolate->SetFatalErrorHandler(reportFatalErrorInMainThread);
-  isolate->AddMessageListener(messageHandlerInMainThread);
+  isolate->AddMessageListenerWithErrorLevel(
+      messageHandlerInMainThread,
+      v8::Isolate::kMessageError | v8::Isolate::kMessageWarning |
+          v8::Isolate::kMessageInfo | v8::Isolate::kMessageDebug |
+          v8::Isolate::kMessageLog);
   isolate->SetFailedAccessCheckCallbackFunction(
       failedAccessCheckCallbackInMainThread);
   isolate->SetAllowCodeGenerationFromStringsCallback(
       codeGenerationCheckCallbackInMainThread);
 
   if (RuntimeEnabledFeatures::v8IdleTasksEnabled()) {
     WebScheduler* scheduler = Platform::current()->currentThread()->scheduler();
     V8PerIsolateData::enableIdleTasks(
         isolate, WTF::makeUnique<V8IdleTaskRunner>(scheduler));
   }
@@ skipping 49 matching lines @@
   // WorkerGlobalScope::dispatchErrorEvent will send the exception to the worker
   // object.
   if (perIsolateData->isReportingException())
     return;
 
   perIsolateData->setReportingException(true);
 
   ExecutionContext* context = scriptState->getExecutionContext();
   std::unique_ptr<SourceLocation> location =
       SourceLocation::fromMessage(isolate, message, context);
+
+  if (message->ErrorLevel() != v8::Isolate::kMessageError) {
+    context->addConsoleMessage(ConsoleMessage::create(
+        JSMessageSource,
+        MessageLevelFromNonFatalErrorLevel(message->ErrorLevel()),
+        toCoreStringWithNullCheck(message->Get()), std::move(location)));
+    return;
+  }
+
   ErrorEvent* event =
       ErrorEvent::create(toCoreStringWithNullCheck(message->Get()),
                          std::move(location), &scriptState->world());
 
   AccessControlStatus corsStatus = message->IsSharedCrossOrigin()
                                        ? SharableCrossOrigin
                                        : NotSharableCrossOrigin;
 
   // If execution termination has been triggered as part of constructing
   // the error event from the v8::Message, quietly leave.
@@ skipping 12 matching lines @@
 static const int kWorkerMaxStackSize = 500 * 1024;
 
 // This function uses a local stack variable to determine the isolate's stack
 // limit. AddressSanitizer may relocate that local variable to a fake stack,
 // which may lead to problems during JavaScript execution.  Therefore we disable
 // AddressSanitizer for V8Initializer::initializeWorker().
 NO_SANITIZE_ADDRESS
 void V8Initializer::initializeWorker(v8::Isolate* isolate) {
   initializeV8Common(isolate);
 
-  isolate->AddMessageListener(messageHandlerInWorker);
+  isolate->AddMessageListenerWithErrorLevel(
+      messageHandlerInWorker,
+      v8::Isolate::kMessageError | v8::Isolate::kMessageWarning |
+          v8::Isolate::kMessageInfo | v8::Isolate::kMessageDebug |
+          v8::Isolate::kMessageLog);
   isolate->SetFatalErrorHandler(reportFatalErrorInWorker);
 
   uint32_t here;
   isolate->SetStackLimit(reinterpret_cast<uintptr_t>(&here) -
                          kWorkerMaxStackSize);
   isolate->SetPromiseRejectCallback(promiseRejectHandlerInWorker);
 }
 
 }  // namespace blink