[DevTools] Move CommandLineAPI.getEventListeners to native

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/ScriptCallStack.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"
@@ skipping 42 matching lines @@
 void ThreadDebugger::beginUserGesture()
 {
     m_userGestureIndicator = adoptPtr(new UserGestureIndicator(DefinitelyProcessingNewUserGesture));
 }
 
 void ThreadDebugger::endUserGesture()
 {
     m_userGestureIndicator.clear();
 }
 
-void ThreadDebugger::eventListeners(v8::Local<v8::Value> value, V8EventListenerInfoList& result)
-{
-    InspectorDOMDebuggerAgent::eventListenersInfoForTarget(m_isolate, value, result);
-}
-
 String16 ThreadDebugger::valueSubtype(v8::Local<v8::Value> value)
 {
     if (V8Node::hasInstance(value, m_isolate))
         return "node";
     if (V8NodeList::hasInstance(value, m_isolate)
         || V8DOMTokenList::hasInstance(value, m_isolate)
         || V8HTMLCollection::hasInstance(value, m_isolate)
         || V8HTMLAllCollection::hasInstance(value, m_isolate)) {
         return "array";
     }
@@ skipping 46 matching lines @@
     if (v8::Function::New(context, returnDataCallback, returnValue).ToLocal(&toStringFunction))
         func->Set(v8String(context->GetIsolate(), "toString"), toStringFunction);
     if (!object->Set(context, funcName, func).FromMaybe(false))
         return;
 }
 
 bool ThreadDebugger::isCommandLineAPIMethod(const String& name)
 {
     DEFINE_STATIC_LOCAL(HashSet<String>, methods, ());
     if (methods.size() == 0) {
-        const char* members[] = { "monitorEvents", "unmonitorEvents" };
+        const char* members[] = { "monitorEvents", "unmonitorEvents", "getEventListeners" };
         for (size_t i = 0; i < WTF_ARRAY_LENGTH(members); ++i)
             methods.add(members[i]);
     }
     return methods.find(name) != methods.end() || V8Debugger::isCommandLineAPIMethod(name);
 }
 
 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] }");
 }
 
 static Vector<String> normalizeEventTypes(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     v8::Isolate* isolate = info.GetIsolate();
     v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
     Vector<String> types;
     if (info.Length() > 1 && info[1]->IsString())
         types.append(toCoreString(info[1].As<v8::String>()));
@@ skipping 81 matching lines @@
     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);
     }
 }
 
+static void removeEventListenerCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
+{
+    v8::Isolate* isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    EventTarget* eventTarget = V8EventTarget::toImplWithTypeCheck(isolate, info.Data());
+    if (!eventTarget)
+        return;
+    v8::Local<v8::Value> thisHandler;
+    if (!info.Holder()->Get(context, v8String(isolate, "listener")).ToLocal(&thisHandler) || !thisHandler->IsObject())
+        return;
+    v8::Local<v8::Value> v8ThisType;
+    if (!info.Holder()->Get(context, v8String(isolate, "type")).ToLocal(&v8ThisType) || !v8ThisType->IsString())
+        return;
+    AtomicString thisType = AtomicString(toCoreString(v8::Local<v8::String>::Cast(v8ThisType)));
+    v8::Local<v8::Value> thisUseCapture;
+    if (!info.Holder()->Get(context, v8String(isolate, "useCapture")).ToLocal(&thisUseCapture) || !thisUseCapture->IsBoolean())
+        return;
+
+    EventListener* eventListener = V8EventListenerList::getEventListener(ScriptState::current(info.GetIsolate()), thisHandler, false, ListenerFindOnly);
+    if (!eventListener)
+        eventListener = V8EventListenerList::getEventListener(ScriptState::current(info.GetIsolate()), thisHandler, true, ListenerFindOnly);
+    if (!eventListener)
+        return;
+    EventListenerOptions options;
+    options.setCapture(v8::Local<v8::Boolean>::Cast(thisUseCapture)->Value());

[dgozman, 2016/05/20 18:48:21]

// TODO(dtapuska): we should pass "passive" flag as well, but there is no such
API yet.

[dtapuska, 2016/05/20 18:50:50]

No remove; doesn't have a passive flag. It isn't a filter for remove.

[kozy, 2016/05/20 18:56:59]

Done.

+    eventTarget->removeEventListener(thisType, eventListener, options);
+}
+
+// static
+void ThreadDebugger::getEventListenersCallback(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);
+    v8::Isolate* isolate = info.GetIsolate();
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+    V8EventListenerInfoList listenerInfo;
+    // eventListeners call can produce message on ErrorEvent during lazy event listener compilation.
+    debugger->muteWarningsAndDeprecations();
+    InspectorDOMDebuggerAgent::eventListenersInfoForTarget(isolate, info[0], listenerInfo);
+    debugger->unmuteWarningsAndDeprecations();
+
+    v8::Local<v8::Object> result = v8::Object::New(isolate);
+
+    v8::Local<v8::Function> removeFunc = v8::Function::New(isolate, removeEventListenerCallback, info[0]);
+    v8::Local<v8::Function> toStringFunction;
+    if (v8::Function::New(context, returnDataCallback, v8String(isolate, "function remove() { [Command Line API] }")).ToLocal(&toStringFunction))
+        removeFunc->Set(v8String(context->GetIsolate(), "toString"), toStringFunction);
+
+    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));
+        listenerObject->Set(v8String(isolate, "remove"), removeFunc);
+        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);
 
@@ skipping 49 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