[DevTools] Remove V8Debugger::logToConsole method

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/SourceLocation.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 "bindings/core/v8/V8ScriptRunner.h"
 #include "core/inspector/ConsoleMessage.h"
 #include "core/inspector/InspectorDOMDebuggerAgent.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/ScriptForbiddenScope.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 namespace blink {
 
@@ skipping 148 matching lines @@
 {
     DCHECK(m_asyncInstrumentationEnabled);
     m_asyncInstrumentationEnabled = false;
 }
 
 static void returnDataCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     info.GetReturnValue().Set(info.Data());
 }
 
-void ThreadDebugger::createFunctionProperty(v8::Local<v8::Context> context, v8::Local<v8::Object> object, const char* name, v8::FunctionCallback callback, const char* description)
+static void createFunctionPropertyWithData(v8::Local<v8::Context> context, v8::Local<v8::Object> object, const char* name, v8::FunctionCallback callback, v8::Local<v8::Value> data, const char* description)
 {
     v8::Local<v8::String> funcName = v8String(context->GetIsolate(), name);
     v8::Local<v8::Function> func;
-    if (!v8::Function::New(context, callback, v8::External::New(context->GetIsolate(), this), 0, v8::ConstructorBehavior::kThrow).ToLocal(&func))
+    if (!v8::Function::New(context, callback, data, 0, v8::ConstructorBehavior::kThrow).ToLocal(&func))
         return;
     func->SetName(funcName);
     v8::Local<v8::String> returnValue = v8String(context->GetIsolate(), description);
     v8::Local<v8::Function> toStringFunction;
     if (v8::Function::New(context, returnDataCallback, returnValue, 0, v8::ConstructorBehavior::kThrow).ToLocal(&toStringFunction))
         func->Set(v8String(context->GetIsolate(), "toString"), toStringFunction);
     if (!object->Set(context, funcName, func).FromMaybe(false))
         return;
 }
 
+void ThreadDebugger::createFunctionProperty(v8::Local<v8::Context> context, v8::Local<v8::Object> object, const char* name, v8::FunctionCallback callback, const char* description)
+{
+    createFunctionPropertyWithData(context, object, name, callback, v8::External::New(context->GetIsolate(), this), description);
+}
+
 void ThreadDebugger::installAdditionalCommandLineAPI(v8::Local<v8::Context> context, v8::Local<v8::Object> object)
 {
-    createFunctionProperty(context, object, "monitorEvents", ThreadDebugger::monitorEventsCallback, "function monitorEvents(object, [types]) { [Command Line API] }");
-    createFunctionProperty(context, object, "unmonitorEvents", ThreadDebugger::unmonitorEventsCallback, "function unmonitorEvents(object, [types]) { [Command Line API] }");
     createFunctionProperty(context, object, "getEventListeners", ThreadDebugger::getEventListenersCallback, "function getEventListeners(node) { [Command Line API] }");
+
+    v8::Local<v8::Value> functionValue;
+    bool success = V8ScriptRunner::compileAndRunInternalScript(v8String(m_isolate, "(function(e) { console.log(e.type, e); })"), m_isolate).ToLocal(&functionValue) && functionValue->IsFunction();
+    DCHECK(success);
+    createFunctionPropertyWithData(context, object, "monitorEvents", ThreadDebugger::monitorEventsCallback, functionValue, "function monitorEvents(object, [types]) { [Command Line API] }");
+    createFunctionPropertyWithData(context, object, "unmonitorEvents", ThreadDebugger::unmonitorEventsCallback, functionValue, "function unmonitorEvents(object, [types]) { [Command Line API] }");
 }
 
 static Vector<String> normalizeEventTypes(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     Vector<String> types;
     if (info.Length() > 1 && info[1]->IsString())
         types.append(toCoreString(info[1].As<v8::String>()));
     if (info.Length() > 1 && info[1]->IsArray()) {
         v8::Local<v8::Array> typesArray = v8::Local<v8::Array>::Cast(info[1]);
         for (size_t i = 0; i < typesArray->Length(); ++i) {
@@ skipping 17 matching lines @@
         else if (types[i] == "pointer")
             outputTypes.appendVector(Vector<String>({ "pointerover", "pointerout", "pointerenter", "pointerleave", "pointerdown", "pointerup", "pointermove", "pointercancel", "gotpointercapture", "lostpointercapture" }));
         else if (types[i] == "control")
             outputTypes.appendVector(Vector<String>({ "resize", "scroll", "zoom", "focus", "blur", "select", "input", "change", "submit", "reset" }));
         else
             outputTypes.append(types[i]);
     }
     return outputTypes;
 }
 
-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;
-    debugger->debugger()->logToConsole(info.GetIsolate()->GetCurrentContext(), v8String(info.GetIsolate(), event->type()), info[0]);
-}
-
-v8::Local<v8::Function> ThreadDebugger::eventLogFunction()
-{
-    if (m_eventLogFunction.IsEmpty())
-        m_eventLogFunction.Reset(m_isolate, v8::Function::New(m_isolate->GetCurrentContext(), logCallback, v8::External::New(m_isolate, this), 0, v8::ConstructorBehavior::kThrow).ToLocalChecked());
-    return m_eventLogFunction.Get(m_isolate);
-}
-
 static EventTarget* firstArgumentAsEventTarget(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     if (info.Length() < 1)
         return nullptr;
     if (EventTarget* target = V8EventTarget::toImplWithTypeCheck(info.GetIsolate(), info[0]))
         return target;
     return toDOMWindow(info.GetIsolate(), info[0]);
 }
 
 void ThreadDebugger::setMonitorEventsCallback(const v8::FunctionCallbackInfo<v8::Value>& info, bool enabled)
 {
     EventTarget* eventTarget = firstArgumentAsEventTarget(info);
     if (!eventTarget)
         return;
     Vector<String> types = normalizeEventTypes(info);
-    ThreadDebugger* debugger = static_cast<ThreadDebugger*>(v8::Local<v8::External>::Cast(info.Data())->Value());
-    DCHECK(debugger);
-    EventListener* eventListener = V8EventListenerList::getEventListener(ScriptState::current(info.GetIsolate()), debugger->eventLogFunction(), false, enabled ? ListenerFindOrCreate : ListenerFindOnly);
+    EventListener* eventListener = V8EventListenerList::getEventListener(ScriptState::current(info.GetIsolate()), v8::Local<v8::Function>::Cast(info.Data()), false, enabled ? ListenerFindOrCreate : ListenerFindOnly);
     if (!eventListener)
         return;
     for (size_t i = 0; i < types.size(); ++i) {
         if (enabled)
             eventTarget->addEventListener(AtomicString(types[i]), eventListener, false);
         else
             eventTarget->removeEventListener(AtomicString(types[i]), eventListener, false);
     }
 }
 
@@ skipping 97 matching lines @@
 {
     for (size_t index = 0; index < m_timers.size(); ++index) {
         if (m_timers[index].get() == timer) {
             m_timerCallbacks[index](m_timerData[index]);
             return;
         }
     }
 }
 
 } // namespace blink