[DevTools] Support JQuery event listeners

Source/core/inspector/InspectorDOMDebuggerAgent.cpp

 /*
  * Copyright (C) 2011 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 326 matching lines @@
         m_domBreakpoints.set(node, mask);
     else
         m_domBreakpoints.remove(node);
 
     if ((rootBit & inheritableDOMBreakpointTypesMask) && !(mask & (rootBit << domBreakpointDerivedTypeShift))) {
         for (Node* child = InspectorDOMAgent::innerFirstChild(node); child; child = InspectorDOMAgent::innerNextSibling(child))
             updateSubtreeBreakpoints(child, rootBit, false);
     }
 }
 
-void InspectorDOMDebuggerAgent::getEventListeners(ErrorString* errorString, const String& objectId, RefPtr<TypeBuilder::Array<TypeBuilder::DOMDebugger::EventListener>>& listenersArray)
+void InspectorDOMDebuggerAgent::getEventListeners(ErrorString* errorString, const String& objectId, const bool* resolveFrameworkHandlers, RefPtr<TypeBuilder::Array<TypeBuilder::DOMDebugger::EventListener>>& listenersArray)
 {
     OwnPtr<RemoteObjectId> remoteId = RemoteObjectId::parse(objectId);
     if (!remoteId) {
         *errorString = "Invalid object id";
         return;
     }
     InjectedScript injectedScript = m_injectedScriptManager->findInjectedScript(remoteId.get());
     if (injectedScript.isEmpty()) {
         *errorString = "Inspected frame has gone";
         return;
     }
-
     ScriptState* state = injectedScript.scriptState();
     ScriptState::Scope scope(state);
     v8::Local<v8::Value> value = injectedScript.findObject(*remoteId);
     if (value.IsEmpty()) {
         *errorString = "No object with passed objectId";
         return;
     }
-    EventTarget* target = InjectedScriptHost::eventTargetFromV8Value(state->isolate(), value);
-    if (!target) {
+    EventTarget* eventTarget = InjectedScriptHost::eventTargetFromV8Value(state->isolate(), value);
+    if (!eventTarget) {
         *errorString = "No event target with passed objectId";
         return;
     }
+    ExecutionContext* executionContext = eventTarget->executionContext();
+    if (!executionContext) {
+        *errorString = "ExecutionContext is empty";
+        return;
+    }
 
+    String objectGroup = injectedScript.objectIdToObjectGroupName(objectId);
     listenersArray = TypeBuilder::Array<TypeBuilder::DOMDebugger::EventListener>::create();
+    eventListeners(executionContext, injectedScript, eventTarget, value, objectGroup, asBool(resolveFrameworkHandlers), listenersArray);
+    if (asBool(resolveFrameworkHandlers))
+        frameworkEventListeners(executionContext, injectedScript, value, objectGroup, listenersArray);
+}
+
+void InspectorDOMDebuggerAgent::eventListeners(ExecutionContext* executionContext, InjectedScript& injectedScript, EventTarget* eventTarget, v8::Local<v8::Value> object, const String& objectGroup, bool filterFrameworkHandlers, RefPtr<TypeBuilder::Array<TypeBuilder::DOMDebugger::EventListener>>& listenersArray)
+{
     WillBeHeapVector<EventListenerInfo> eventInformation;
-    EventListenerInfo::getEventListeners(target, eventInformation, false);
+    EventListenerInfo::getEventListeners(eventTarget, eventInformation, false);
     if (eventInformation.isEmpty())
         return;
+    v8::Local<v8::Set> frameworkHandlers;
+    if (filterFrameworkHandlers)
+        filterFrameworkHandlers = injectedScript.frameworkEventHandlers(object).ToLocal(&frameworkHandlers);
 
-    String objectGroup = injectedScript.objectIdToObjectGroupName(objectId);
     RegisteredEventListenerIterator iterator(eventInformation);
     while (const RegisteredEventListener* listener = iterator.nextRegisteredEventListener()) {
         const EventListenerInfo& info = iterator.currentEventListenerInfo();
-        RefPtr<TypeBuilder::DOMDebugger::EventListener> listenerObject = buildObjectForEventListener(*listener, info.eventType, info.eventTarget, objectGroup);
+        v8::Local<v8::Object> handler = eventListenerHandler(executionContext, listener->listener.get());
+
+        if (filterFrameworkHandlers) {
+            v8::Maybe<bool> hasHandler = frameworkHandlers->Has(frameworkHandlers->CreationContext(), handler);
+            if (hasHandler.IsJust() && hasHandler.FromJust())
+                continue;
+        }
+
+        RefPtr<TypeBuilder::DOMDebugger::EventListener> listenerObject = buildObjectForEventListener(handler, listener->useCapture, info.eventType, executionContext, objectGroup);
         if (listenerObject)
             listenersArray->addItem(listenerObject);
     }
 }
 
-PassRefPtr<TypeBuilder::DOMDebugger::EventListener> InspectorDOMDebuggerAgent::buildObjectForEventListener(const RegisteredEventListener& registeredEventListener, const AtomicString& eventType, EventTarget* target, const String& objectGroupId)
+void InspectorDOMDebuggerAgent::frameworkEventListeners(ExecutionContext* executionContext, InjectedScript& injectedScript, v8::Local<v8::Value> object, const String& objectGroup,  RefPtr<TypeBuilder::Array<TypeBuilder::DOMDebugger::EventListener>>& listenersArray)
 {
-    EventListener* eventListener = registeredEventListener.listener.get();
-    RefPtrWillBeRawPtr<EventListener> protect(eventListener);
+    v8::MaybeLocal<v8::Array> listeners = injectedScript.frameworkEventListeners(object);
+    if (listeners.IsEmpty())
+        return;
+    v8::Local<v8::Array> array = listeners.ToLocalChecked();
+
+    ScriptState* scriptState = injectedScript.scriptState();
+    v8::Isolate* isolate = scriptState->isolate();
+    v8::Local<v8::Context> v8Context(array->CreationContext());
+    for (unsigned i = 0; i < array->Length(); ++i) {
+        v8::Local<v8::Value> listener = array->Get(array->CreationContext(), i).ToLocalChecked();

[yurys, 2015/08/12 21:56:03]

v8Context

+        v8::Local<v8::Object> listenerObject = listener.As<v8::Object>();
+        v8::Local<v8::Function> function = listenerObject->Get(v8Context, v8String(isolate, "handler")).ToLocalChecked().As<v8::Function>();
+        v8::Local<v8::String> eventType = listenerObject->Get(v8Context, v8String(isolate, "type")).ToLocalChecked().As<v8::String>();
+        v8::Local<v8::Boolean> useCapture = listenerObject->Get(v8Context, v8String(isolate, "useCapture")).ToLocalChecked().As<v8::Boolean>();
+        RefPtr<TypeBuilder::DOMDebugger::EventListener> inspectorListenerObject = buildObjectForEventListener(function, useCapture->Value(), toCoreString(eventType), executionContext, objectGroup);
+        if (inspectorListenerObject)
+            listenersArray->addItem(inspectorListenerObject);
+    }
+}
+
+static PassRefPtr<TypeBuilder::Runtime::RemoteObject> eventHandlerObject(ExecutionContext* context, v8::Local<v8::Object> handler, InjectedScriptManager* manager, const String* objectGroupId)
+{
+    if (handler.IsEmpty() || !context->isDocument())
+        return nullptr;
+
+    ScriptState* scriptState = ScriptState::from(handler->CreationContext());
+    LocalFrame* frame = toDocument(context)->frame();
+    if (!frame)
+        return nullptr;
+
+    InjectedScript injectedScript = manager->injectedScriptFor(scriptState);
+    if (!injectedScript.isEmpty())
+        return injectedScript.wrapObject(ScriptValue(scriptState, handler), *objectGroupId);
+    return nullptr;
+}
+
+PassRefPtr<TypeBuilder::DOMDebugger::EventListener> InspectorDOMDebuggerAgent::buildObjectForEventListener(v8::Local<v8::Object> handler, bool useCapture, const String& type, ExecutionContext* context, const String& objectGroupId)
+{
+    if (handler.IsEmpty())
+        return nullptr;
     String scriptId;
     int lineNumber;
     int columnNumber;
-    ExecutionContext* context = target->executionContext();
-    if (!context)
+    v8::Local<v8::Function> function = eventListenerEffectiveFunction(toIsolate(context), handler);
+    if (function.IsEmpty())
         return nullptr;
-    if (!eventListenerHandlerLocation(context, eventListener, scriptId, lineNumber, columnNumber))
-        return nullptr;
-
+    getFunctionLocation(function, scriptId, lineNumber, columnNumber);
     RefPtr<TypeBuilder::Debugger::Location> location = TypeBuilder::Debugger::Location::create()
         .setScriptId(scriptId)
         .setLineNumber(lineNumber);
     location->setColumnNumber(columnNumber);
     RefPtr<TypeBuilder::DOMDebugger::EventListener> value = TypeBuilder::DOMDebugger::EventListener::create()
-        .setType(eventType)
-        .setUseCapture(registeredEventListener.useCapture)
+        .setType(type)
+        .setUseCapture(useCapture)
         .setLocation(location);
     if (!objectGroupId.isEmpty())
-        value->setHandler(eventHandlerObject(context, eventListener, m_injectedScriptManager, &objectGroupId));
+        value->setHandler(eventHandlerObject(context, function, m_injectedScriptManager, &objectGroupId));
     return value.release();
 }
 
 void InspectorDOMDebuggerAgent::willInsertDOMNode(Node* parent)
 {
     if (hasBreakpoint(parent, SubtreeModified)) {
         RefPtr<JSONObject> eventData = JSONObject::create();
         descriptionForDOMEvent(parent, SubtreeModified, true, eventData.get());
         m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::DOM, eventData.release());
     }
@@ skipping 260 matching lines @@
     eventData->setString("url", url);
     m_debuggerAgent->breakProgram(InspectorFrontend::Debugger::Reason::XHR, eventData.release());
 }
 
 void InspectorDOMDebuggerAgent::clear()
 {
     m_domBreakpoints.clear();
 }
 
 } // namespace blink