[DevTools] Move Console to v8 inspector.

third_party/WebKit/Source/core/inspector/ThreadDebugger.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 "core/inspector/ThreadDebugger.h"
 
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8DOMTokenList.h"
 #include "bindings/core/v8/V8Event.h"
 #include "bindings/core/v8/V8EventListener.h"
 #include "bindings/core/v8/V8EventListenerInfo.h"
 #include "bindings/core/v8/V8EventListenerList.h"
 #include "bindings/core/v8/V8HTMLAllCollection.h"
 #include "bindings/core/v8/V8HTMLCollection.h"
 #include "bindings/core/v8/V8Node.h"
 #include "bindings/core/v8/V8NodeList.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorDOMDebuggerAgent.h"
 #include "core/inspector/InspectorTraceEvents.h"
-#include "core/inspector/ScriptArguments.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/OwnPtr.h"
 
 namespace blink {
 
 ThreadDebugger::ThreadDebugger(v8::Isolate* isolate)
     : m_isolate(isolate)
     , m_debugger(V8Debugger::create(isolate, this))
 {
@@ skipping 147 matching lines @@
 
 void ThreadDebugger::logCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return;
     ThreadDebugger* debugger = static_cast<ThreadDebugger*>(v8::Local<v8::External>::Cast(info.Data())->Value());
     DCHECK(debugger);
     Event* event = V8Event::toImplWithTypeCheck(info.GetIsolate(), info[0]);
     if (!event)
         return;
-
-    v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
-    ScriptState* scriptState = ScriptState::from(context);
-    DCHECK(scriptState->contextIsValid());
-    Vector<ScriptValue> arguments = Vector<ScriptValue>({
-        ScriptValue(scriptState, v8String(info.GetIsolate(), event->type())),
-        ScriptValue(scriptState, info[0])
-    });
-
-    ConsoleMessage* consoleMessage = ConsoleMessage::createForConsoleAPI(LogMessageLevel, LogMessageType, event->type(), ScriptArguments::create(scriptState, arguments));
-    debugger->reportMessageToConsole(context, consoleMessage);
+    protocol::Vector<v8::Local<v8::Value>> arguments;
+    arguments.append(v8String(info.GetIsolate(), event->type()));
+    arguments.append(info[0]);
+    debugger->debugger()->logToConsole(info.GetIsolate()->GetCurrentContext(), event->type(), &arguments);
 }
 
 v8::Local<v8::Function> ThreadDebugger::eventLogFunction()
 {
     if (m_eventLogFunction.IsEmpty())
         m_eventLogFunction.Reset(m_isolate, v8::Function::New(m_isolate, logCallback, v8::External::New(m_isolate, this)));
     return m_eventLogFunction.Get(m_isolate);
 }
 
 static EventTarget* firstArgumentAsEventTarget(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ skipping 42 matching lines @@
     if (info.Length() < 1)
         return;
 
     ThreadDebugger* debugger = static_cast<ThreadDebugger*>(v8::Local<v8::External>::Cast(info.Data())->Value());
     DCHECK(debugger);
     v8::Isolate* isolate = info.GetIsolate();
 
     V8EventListenerInfoList listenerInfo;
     // eventListeners call can produce message on ErrorEvent during lazy event listener compilation.
     debugger->muteWarningsAndDeprecations();
+    debugger->debugger()->muteConsole();
     InspectorDOMDebuggerAgent::eventListenersInfoForTarget(isolate, info[0], listenerInfo);
+    debugger->debugger()->unmuteConsole();
     debugger->unmuteWarningsAndDeprecations();
 
     v8::Local<v8::Object> result = v8::Object::New(isolate);
     AtomicString currentEventType;
     v8::Local<v8::Array> listeners;
     size_t outputIndex = 0;
     for (auto& info : listenerInfo) {
         if (currentEventType != info.eventType) {
             currentEventType = info.eventType;
             listeners = v8::Array::New(isolate);
             outputIndex = 0;
             result->Set(v8String(isolate, currentEventType), listeners);
         }
 
         v8::Local<v8::Object> listenerObject = v8::Object::New(isolate);
         listenerObject->Set(v8String(isolate, "listener"), info.handler);
         listenerObject->Set(v8String(isolate, "useCapture"), v8::Boolean::New(isolate, info.useCapture));
         listenerObject->Set(v8String(isolate, "passive"), v8::Boolean::New(isolate, info.passive));
         listenerObject->Set(v8String(isolate, "type"), v8String(isolate, currentEventType));
         v8::Local<v8::Function> removeFunction;
         if (info.removeFunction.ToLocal(&removeFunction))
             listenerObject->Set(v8String(isolate, "remove"), removeFunction);
         listeners->Set(outputIndex++, listenerObject);
     }
     info.GetReturnValue().Set(result);
 }
 
-void ThreadDebugger::reportMessageToConsole(v8::Local<v8::Context> context, MessageType type, MessageLevel level, const String16& message, const v8::FunctionCallbackInfo<v8::Value>* arguments, unsigned skipArgumentCount)
-{
-    ScriptState* scriptState = ScriptState::from(context);
-    ScriptArguments* scriptArguments = nullptr;
-    if (arguments && scriptState->contextIsValid())
-        scriptArguments = ScriptArguments::create(scriptState, *arguments, skipArgumentCount);
-    String messageText = message;
-    if (messageText.isEmpty() && scriptArguments)
-        scriptArguments->getFirstArgumentAsString(messageText);
-
-    reportMessageToConsole(context, ConsoleMessage::createForConsoleAPI(level, type, messageText, scriptArguments));
-}
-
 void ThreadDebugger::consoleTime(const String16& title)
 {
     TRACE_EVENT_COPY_ASYNC_BEGIN0("blink.console", String(title).utf8().data(), this);
 }
 
 void ThreadDebugger::consoleTimeEnd(const String16& title)
 {
     TRACE_EVENT_COPY_ASYNC_END0("blink.console", String(title).utf8().data(), this);
 }
 
@@ skipping 31 matching lines @@
 {
     for (size_t index = 0; index < m_timers.size(); ++index) {
         if (m_timers[index] == timer) {
             m_timerCallbacks[index](m_timerData[index]);
             return;
         }
     }
 }
 
 } // namespace blink