Unreviewed, rolling out r224863.
[WebKit-https.git] / Source / WebCore / inspector / CommandLineAPIHost.cpp
index 3b976da..7a8f95c 100644 (file)
 #include "CommandLineAPIHost.h"
 
 #include "Database.h"
-#include "Element.h"
-#include "Frame.h"
-#include "FrameLoader.h"
-#include "HTMLFrameOwnerElement.h"
-#include "InspectorClient.h"
+#include "Document.h"
 #include "InspectorDOMAgent.h"
 #include "InspectorDOMStorageAgent.h"
 #include "InspectorDatabaseAgent.h"
-#include <inspector/InspectorFrontendDispatchers.h>
+#include "JSCommandLineAPIHost.h"
+#include "JSDOMGlobalObject.h"
+#include "JSEventListener.h"
 #include "Pasteboard.h"
 #include "Storage.h"
-#include "markup.h"
 #include <bindings/ScriptValue.h>
 #include <inspector/InspectorValues.h>
 #include <inspector/agents/InspectorAgent.h>
 #include <inspector/agents/InspectorConsoleAgent.h>
+#include <runtime/JSCInlines.h>
+#include <runtime/JSLock.h>
 #include <wtf/RefPtr.h>
 #include <wtf/StdLibExtras.h>
 
-using namespace Inspector;
-
 namespace WebCore {
 
+using namespace JSC;
+using namespace Inspector;
+
 Ref<CommandLineAPIHost> CommandLineAPIHost::create()
 {
     return adoptRef(*new CommandLineAPIHost);
 }
 
 CommandLineAPIHost::CommandLineAPIHost()
-    : m_inspectorAgent(nullptr)
-    , m_consoleAgent(nullptr)
-    , m_domAgent(nullptr)
-    , m_domStorageAgent(nullptr)
-    , m_databaseAgent(nullptr)
+    : m_inspectedObject(std::make_unique<InspectableObject>())
 {
-    m_inspectedObject = std::make_unique<InspectableObject>();
 }
 
-CommandLineAPIHost::~CommandLineAPIHost()
-{
-}
+CommandLineAPIHost::~CommandLineAPIHost() = default;
 
 void CommandLineAPIHost::disconnect()
 {
@@ -83,23 +76,66 @@ void CommandLineAPIHost::disconnect()
     m_databaseAgent = nullptr;
 }
 
-void CommandLineAPIHost::inspectImpl(RefPtr<InspectorValue>&& object, RefPtr<InspectorValue>&& hints)
+void CommandLineAPIHost::inspect(JSC::ExecState& state, JSC::JSValue valueToInspect, JSC::JSValue hintsValue)
 {
     if (!m_inspectorAgent)
         return;
 
     RefPtr<InspectorObject> hintsObject;
-    if (!hints->asObject(hintsObject))
+    if (!Inspector::toInspectorValue(state, hintsValue)->asObject(hintsObject))
         return;
 
-    auto remoteObject = BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(WTF::move(object));
-    m_inspectorAgent->inspect(WTF::move(remoteObject), WTF::move(hintsObject));
+    auto remoteObject = BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(Inspector::toInspectorValue(state, valueToInspect));
+    m_inspectorAgent->inspect(WTFMove(remoteObject), WTFMove(hintsObject));
+}
+
+static Vector<CommandLineAPIHost::ListenerEntry> listenerEntriesFromListenerInfo(ExecState& state, Document& document, const EventListenerInfo& listenerInfo)
+{
+    VM& vm = state.vm();
+
+    Vector<CommandLineAPIHost::ListenerEntry> entries;
+    for (auto& eventListener : listenerInfo.eventListenerVector) {
+        auto jsListener = JSEventListener::cast(&eventListener->callback());
+        if (!jsListener) {
+            ASSERT_NOT_REACHED();
+            continue;
+        }
+
+        // Hide listeners from other contexts.
+        if (&jsListener->isolatedWorld() != &currentWorld(&state))
+            continue;
+
+        auto function = jsListener->jsFunction(document);
+        if (!function)
+            continue;
+
+        entries.append({ JSC::Strong<JSC::JSObject>(vm, function), eventListener->useCapture(), eventListener->isPassive(), eventListener->isOnce() });
+    }
+
+    return entries;
 }
 
-void CommandLineAPIHost::getEventListenersImpl(Node* node, Vector<EventListenerInfo>& listenersArray)
+auto CommandLineAPIHost::getEventListeners(JSC::ExecState& state, Node* node) -> EventListenersRecord
 {
-    if (m_domAgent)
-        m_domAgent->getEventListeners(node, listenersArray, false);
+    if (!m_domAgent)
+        return { };
+
+    if (!node)
+        return { };
+
+    Vector<EventListenerInfo> listenerInfoArray;
+    m_domAgent->getEventListeners(node, listenerInfoArray, false);
+
+    EventListenersRecord result;
+
+    for (auto& listenerInfo : listenerInfoArray) {
+        auto entries = listenerEntriesFromListenerInfo(state, node->document(), listenerInfo);
+        if (entries.isEmpty())
+            continue;
+        result.append({ listenerInfo.eventType, WTFMove(entries) });
+    }
+
+    return result;
 }
 
 void CommandLineAPIHost::clearConsoleMessages()
@@ -115,33 +151,58 @@ void CommandLineAPIHost::copyText(const String& text)
     Pasteboard::createForCopyAndPaste()->writePlainText(text, Pasteboard::CannotSmartReplace);
 }
 
-Deprecated::ScriptValue CommandLineAPIHost::InspectableObject::get(JSC::ExecState*)
+JSC::JSValue CommandLineAPIHost::InspectableObject::get(JSC::ExecState&)
 {
-    return Deprecated::ScriptValue();
+    return { };
 }
 
 void CommandLineAPIHost::addInspectedObject(std::unique_ptr<CommandLineAPIHost::InspectableObject> object)
 {
-    m_inspectedObject = WTF::move(object);
+    m_inspectedObject = WTFMove(object);
 }
 
-CommandLineAPIHost::InspectableObject* CommandLineAPIHost::inspectedObject()
+JSC::JSValue CommandLineAPIHost::inspectedObject(JSC::ExecState& state)
 {
-    return m_inspectedObject.get();
+    if (!m_inspectedObject)
+        return jsUndefined();
+
+    JSC::JSLockHolder lock(&state);
+    auto scriptValue = m_inspectedObject->get(state);
+    return scriptValue ? scriptValue : jsUndefined();
 }
 
-String CommandLineAPIHost::databaseIdImpl(Database* database)
+String CommandLineAPIHost::databaseId(Database& database)
 {
     if (m_databaseAgent)
         return m_databaseAgent->databaseId(database);
-    return String();
+    return { };
 }
 
-String CommandLineAPIHost::storageIdImpl(Storage* storage)
+String CommandLineAPIHost::storageId(Storage& storage)
 {
     if (m_domStorageAgent)
         return m_domStorageAgent->storageId(storage);
-    return String();
+    return { };
+}
+
+JSValue CommandLineAPIHost::wrapper(ExecState* exec, JSDOMGlobalObject* globalObject)
+{
+    JSValue value = m_wrappers.getWrapper(globalObject);
+    if (value)
+        return value;
+
+    JSObject* prototype = JSCommandLineAPIHost::createPrototype(exec->vm(), *globalObject);
+    Structure* structure = JSCommandLineAPIHost::createStructure(exec->vm(), globalObject, prototype);
+    JSCommandLineAPIHost* commandLineAPIHost = JSCommandLineAPIHost::create(structure, globalObject, makeRef(*this));
+    m_wrappers.addWrapper(globalObject, commandLineAPIHost);
+
+    return commandLineAPIHost;
+}
+
+void CommandLineAPIHost::clearAllWrappers()
+{
+    m_wrappers.clearAllWrappers();
+    m_inspectedObject = std::make_unique<InspectableObject>();
 }
 
 } // namespace WebCore