Use more references in event dispatch code
[WebKit-https.git] / Source / WebCore / inspector / CommandLineAPIHost.cpp
1 /*
2  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
3  * Copyright (C) 2008 Matt Lilek <webkit@mattlilek.com>
4  * Copyright (C) 2010 Google Inc. All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
10  * 1.  Redistributions of source code must retain the above copyright
11  *     notice, this list of conditions and the following disclaimer.
12  * 2.  Redistributions in binary form must reproduce the above copyright
13  *     notice, this list of conditions and the following disclaimer in the
14  *     documentation and/or other materials provided with the distribution.
15  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
16  *     its contributors may be used to endorse or promote products derived
17  *     from this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
20  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
23  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29  */
30
31 #include "config.h"
32 #include "CommandLineAPIHost.h"
33
34 #include "Database.h"
35 #include "Document.h"
36 #include "InspectorDOMAgent.h"
37 #include "InspectorDOMStorageAgent.h"
38 #include "InspectorDatabaseAgent.h"
39 #include "JSCommandLineAPIHost.h"
40 #include "JSDOMGlobalObject.h"
41 #include "JSEventListener.h"
42 #include "Pasteboard.h"
43 #include "Storage.h"
44 #include <bindings/ScriptValue.h>
45 #include <inspector/InspectorValues.h>
46 #include <inspector/agents/InspectorAgent.h>
47 #include <inspector/agents/InspectorConsoleAgent.h>
48 #include <runtime/JSCInlines.h>
49 #include <runtime/JSLock.h>
50 #include <wtf/RefPtr.h>
51 #include <wtf/StdLibExtras.h>
52
53 using namespace JSC;
54 using namespace Inspector;
55
56 namespace WebCore {
57
58 Ref<CommandLineAPIHost> CommandLineAPIHost::create()
59 {
60     return adoptRef(*new CommandLineAPIHost);
61 }
62
63 CommandLineAPIHost::CommandLineAPIHost()
64     : m_inspectedObject(std::make_unique<InspectableObject>())
65 {
66 }
67
68 CommandLineAPIHost::~CommandLineAPIHost()
69 {
70 }
71
72 void CommandLineAPIHost::disconnect()
73 {
74     m_inspectorAgent = nullptr;
75     m_consoleAgent = nullptr;
76     m_domAgent = nullptr;
77     m_domStorageAgent = nullptr;
78     m_databaseAgent = nullptr;
79 }
80
81 void CommandLineAPIHost::inspect(JSC::ExecState& state, JSC::JSValue valueToInspect, JSC::JSValue hintsValue)
82 {
83     if (!m_inspectorAgent)
84         return;
85
86     RefPtr<InspectorObject> hintsObject;
87     if (!Inspector::toInspectorValue(state, hintsValue)->asObject(hintsObject))
88         return;
89
90     auto remoteObject = BindingTraits<Inspector::Protocol::Runtime::RemoteObject>::runtimeCast(Inspector::toInspectorValue(state, valueToInspect));
91     m_inspectorAgent->inspect(WTFMove(remoteObject), WTFMove(hintsObject));
92 }
93
94 static Vector<CommandLineAPIHost::ListenerEntry> listenerEntriesFromListenerInfo(ExecState& state, Document& document, const EventListenerInfo& listenerInfo)
95 {
96     VM& vm = state.vm();
97
98     Vector<CommandLineAPIHost::ListenerEntry> entires;
99     for (auto& eventListener : listenerInfo.eventListenerVector) {
100         auto jsListener = JSEventListener::cast(&eventListener->callback());
101         if (!jsListener) {
102             ASSERT_NOT_REACHED();
103             continue;
104         }
105
106         // Hide listeners from other contexts.
107         if (&jsListener->isolatedWorld() != &currentWorld(&state))
108             continue;
109
110         auto function = jsListener->jsFunction(document);
111         if (!function)
112             continue;
113
114         entires.append({ JSC::Strong<JSC::JSObject>(vm, function), eventListener->useCapture() });
115     }
116
117     return entires;
118 }
119
120 auto CommandLineAPIHost::getEventListeners(JSC::ExecState& state, Node* node) -> EventListenersRecord
121 {
122     if (m_domAgent)
123         return { };
124
125     if (!node)
126         return { };
127
128     Vector<EventListenerInfo> listenerInfoArray;
129     m_domAgent->getEventListeners(node, listenerInfoArray, false);
130
131     EventListenersRecord result;
132
133     for (auto& listenerInfo : listenerInfoArray) {
134         auto entries = listenerEntriesFromListenerInfo(state, node->document(), listenerInfo);
135         if (entries.isEmpty())
136             continue;
137         result.append({ listenerInfo.eventType, WTFMove(entries) });
138     }
139
140     return result;
141 }
142
143 void CommandLineAPIHost::clearConsoleMessages()
144 {
145     if (m_consoleAgent) {
146         ErrorString unused;
147         m_consoleAgent->clearMessages(unused);
148     }
149 }
150
151 void CommandLineAPIHost::copyText(const String& text)
152 {
153     Pasteboard::createForCopyAndPaste()->writePlainText(text, Pasteboard::CannotSmartReplace);
154 }
155
156 JSC::JSValue CommandLineAPIHost::InspectableObject::get(JSC::ExecState&)
157 {
158     return { };
159 }
160
161 void CommandLineAPIHost::addInspectedObject(std::unique_ptr<CommandLineAPIHost::InspectableObject> object)
162 {
163     m_inspectedObject = WTFMove(object);
164 }
165
166 JSC::JSValue CommandLineAPIHost::inspectedObject(JSC::ExecState& state)
167 {
168     if (!m_inspectedObject)
169         return jsUndefined();
170
171     JSC::JSLockHolder lock(&state);
172     auto scriptValue = m_inspectedObject->get(state);
173     return scriptValue ? scriptValue : jsUndefined();
174 }
175
176 String CommandLineAPIHost::databaseId(Database& database)
177 {
178     if (m_databaseAgent)
179         return m_databaseAgent->databaseId(database);
180     return { };
181 }
182
183 String CommandLineAPIHost::storageId(Storage& storage)
184 {
185     if (m_domStorageAgent)
186         return m_domStorageAgent->storageId(storage);
187     return { };
188 }
189
190 JSValue CommandLineAPIHost::wrapper(ExecState* exec, JSDOMGlobalObject* globalObject)
191 {
192     JSValue value = m_wrappers.getWrapper(globalObject);
193     if (value)
194         return value;
195
196     JSObject* prototype = JSCommandLineAPIHost::createPrototype(exec->vm(), *globalObject);
197     Structure* structure = JSCommandLineAPIHost::createStructure(exec->vm(), globalObject, prototype);
198     JSCommandLineAPIHost* commandLineAPIHost = JSCommandLineAPIHost::create(structure, globalObject, makeRef(*this));
199     m_wrappers.addWrapper(globalObject, commandLineAPIHost);
200
201     return commandLineAPIHost;
202 }
203
204 void CommandLineAPIHost::clearAllWrappers()
205 {
206     m_wrappers.clearAllWrappers();
207     m_inspectedObject = std::make_unique<InspectableObject>();
208 }
209
210 } // namespace WebCore