[DevTools] Event Listeners Sidebar shows window listeners

Source/core/inspector/InspectorDOMAgent.cpp

 /*
  * Copyright (C) 2009 Apple Inc. All rights reserved.
  * Copyright (C) 2011 Google Inc. All rights reserved.
  * Copyright (C) 2009 Joseph Pecoraro
  *
  * 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
@@ skipping 930 matching lines @@
     getEventListeners(node, eventInformation, true);
 
     // Get Capturing Listeners (in this order)
     size_t eventInformationLength = eventInformation.size();
     for (size_t i = 0; i < eventInformationLength; ++i) {
         const EventListenerInfo& info = eventInformation[i];
         const EventListenerVector& vector = info.eventListenerVector;
         for (size_t j = 0; j < vector.size(); ++j) {
             const RegisteredEventListener& listener = vector[j];
             if (listener.useCapture) {
-                RefPtr<TypeBuilder::DOM::EventListener> listenerObject = buildObjectForEventListener(listener, info.eventType, info.eventTarget->toNode(), objectGroup);
+                RefPtr<TypeBuilder::DOM::EventListener> listenerObject = buildObjectForEventListener(listener, info.eventType, info.eventTarget, objectGroup);
                 if (listenerObject)
                     listenersArray->addItem(listenerObject);
             }
         }
     }
 
     // Get Bubbling Listeners (reverse order)
     for (size_t i = eventInformationLength; i; --i) {
         const EventListenerInfo& info = eventInformation[i - 1];
         const EventListenerVector& vector = info.eventListenerVector;
         for (size_t j = 0; j < vector.size(); ++j) {
             const RegisteredEventListener& listener = vector[j];
             if (!listener.useCapture) {
-                RefPtr<TypeBuilder::DOM::EventListener> listenerObject = buildObjectForEventListener(listener, info.eventType, info.eventTarget->toNode(), objectGroup);
+                RefPtr<TypeBuilder::DOM::EventListener> listenerObject = buildObjectForEventListener(listener, info.eventType, info.eventTarget, objectGroup);
                 if (listenerObject)
                     listenersArray->addItem(listenerObject);
             }
         }
     }
 }
 
 void InspectorDOMAgent::getEventListeners(EventTarget* target, Vector<EventListenerInfo>& eventInformation, bool includeAncestors)
 {
     // The Node's Ancestors including self.
     Vector<EventTarget*> ancestors;
     ancestors.append(target);
     if (includeAncestors) {
         Node* node = target->toNode();
         for (ContainerNode* ancestor = node ? node->parentOrShadowHostNode() : nullptr; ancestor; ancestor = ancestor->parentOrShadowHostNode())
             ancestors.append(ancestor);
+        if (ExecutionContext* context = target->executionContext()) {
+            if (LocalDOMWindow* window = context->executingWindow())
+                ancestors.append(window);
+        }
     }
 
     // Nodes and their Listeners for the concerned event types (order is top to bottom)
     for (size_t i = ancestors.size(); i; --i) {
         EventTarget* ancestor = ancestors[i - 1];
         Vector<AtomicString> eventTypes = ancestor->eventTypes();
         for (size_t j = 0; j < eventTypes.size(); ++j) {
             AtomicString& type = eventTypes[j];
             const EventListenerVector& listeners = ancestor->getEventListeners(type);
             EventListenerVector filteredListeners;
@@ skipping 757 matching lines @@
     depth--;
     m_childrenRequested.add(bind(container, nodesMap));
 
     while (child) {
         children->addItem(buildObjectForNode(child, depth, nodesMap));
         child = innerNextSibling(child);
     }
     return children.release();
 }
 
-PassRefPtr<TypeBuilder::DOM::EventListener> InspectorDOMAgent::buildObjectForEventListener(const RegisteredEventListener& registeredEventListener, const AtomicString& eventType, Node* node, const String* objectGroupId)
+PassRefPtr<TypeBuilder::DOM::EventListener> InspectorDOMAgent::buildObjectForEventListener(const RegisteredEventListener& registeredEventListener, const AtomicString& eventType, EventTarget* target, const String* objectGroupId)
 {
     RefPtr<EventListener> eventListener = registeredEventListener.listener;
     String scriptId;
     int lineNumber;
     int columnNumber;
-    if (!eventListenerHandlerLocation(&node->document(), eventListener.get(), scriptId, lineNumber, columnNumber))
+    Document* document = nullptr;
+    if (Node* node = target->toNode())
+        document = &node->document();
+    else if (DOMWindow* window = target->toDOMWindow())
+        document = window->document();
+
+    if (!document)
+        return nullptr;
+    if (!eventListenerHandlerLocation(document, eventListener.get(), scriptId, lineNumber, columnNumber))
         return nullptr;
 
-    Document& document = node->document();
     RefPtr<TypeBuilder::Debugger::Location> location = TypeBuilder::Debugger::Location::create()
         .setScriptId(scriptId)
         .setLineNumber(lineNumber);
     location->setColumnNumber(columnNumber);
     RefPtr<TypeBuilder::DOM::EventListener> value = TypeBuilder::DOM::EventListener::create()
         .setType(eventType)
         .setUseCapture(registeredEventListener.useCapture)
         .setIsAttribute(eventListener->isAttribute())
-        .setNodeId(pushNodePathToFrontend(node))
         .setLocation(location);
+
+    if (Node* node = target->toNode())
+        value->setNodeId(pushNodePathToFrontend(node));
+
     if (objectGroupId) {
-        ScriptValue functionValue = eventListenerHandler(&document, eventListener.get());
+        ScriptValue functionValue = eventListenerHandler(document, eventListener.get());
         if (!functionValue.isEmpty()) {
-            LocalFrame* frame = document.frame();
+            LocalFrame* frame = document->frame();
             if (frame) {
                 ScriptState* scriptState = eventListenerHandlerScriptState(frame, eventListener.get());
                 if (scriptState) {
                     InjectedScript injectedScript = m_injectedScriptManager->injectedScriptFor(scriptState);
                     if (!injectedScript.isEmpty()) {
                         RefPtr<TypeBuilder::Runtime::RemoteObject> valueJson = injectedScript.wrapObject(functionValue, *objectGroupId);
                         value->setHandler(valueJson);
                     }
                 }
             }
@@ skipping 506 matching lines @@
     visitor->trace(m_searchResults);
 #endif
     visitor->trace(m_hoveredNodeForInspectMode);
     visitor->trace(m_history);
     visitor->trace(m_domEditor);
     visitor->trace(m_listener);
     InspectorBaseAgent::trace(visitor);
 }
 
 } // namespace blink