0f74e6c1401d8badd4a456b11cc9cf94b7a81477
[WebKit.git] / Source / WebCore / bindings / js / ScheduledAction.cpp
1 /*
2  *  Copyright (C) 2000 Harri Porten (porten@kde.org)
3  *  Copyright (C) 2006 Jon Shier (jshier@iastate.edu)
4  *  Copyright (C) 2003-2017 Apple Inc. All rights reseved.
5  *  Copyright (C) 2006 Alexey Proskuryakov (ap@webkit.org)
6  *  Copyright (C) 2009 Google Inc. All rights reseved.
7  *
8  *  This library is free software; you can redistribute it and/or
9  *  modify it under the terms of the GNU Lesser General Public
10  *  License as published by the Free Software Foundation; either
11  *  version 2 of the License, or (at your option) any later version.
12  *
13  *  This library is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  *  Lesser General Public License for more details.
17  *
18  *  You should have received a copy of the GNU Lesser General Public
19  *  License along with this library; if not, write to the Free Software
20  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301
21  *  USA
22  */
23
24 #include "config.h"
25 #include "ScheduledAction.h"
26
27 #include "ContentSecurityPolicy.h"
28 #include "DOMWindow.h"
29 #include "DOMWrapperWorld.h"
30 #include "Document.h"
31 #include "Frame.h"
32 #include "FrameLoader.h"
33 #include "JSDOMExceptionHandling.h"
34 #include "JSDOMWindow.h"
35 #include "JSMainThreadExecState.h"
36 #include "JSMainThreadExecStateInstrumentation.h"
37 #include "JSWorkerGlobalScope.h"
38 #include "ScriptController.h"
39 #include "ScriptExecutionContext.h"
40 #include "ScriptSourceCode.h"
41 #include "WorkerGlobalScope.h"
42 #include "WorkerThread.h"
43 #include <runtime/JSLock.h>
44
45
46 namespace WebCore {
47 using namespace JSC;
48
49 std::unique_ptr<ScheduledAction> ScheduledAction::create(DOMWrapperWorld& isolatedWorld, JSC::Strong<JSC::Unknown>&& function)
50 {
51     return std::unique_ptr<ScheduledAction>(new ScheduledAction(isolatedWorld, WTFMove(function)));
52 }
53
54 std::unique_ptr<ScheduledAction> ScheduledAction::create(DOMWrapperWorld& isolatedWorld, String&& code)
55 {
56     return std::unique_ptr<ScheduledAction>(new ScheduledAction(isolatedWorld, WTFMove(code)));
57 }
58
59 ScheduledAction::ScheduledAction(DOMWrapperWorld& isolatedWorld, JSC::Strong<JSC::Unknown>&& function)
60     : m_isolatedWorld(isolatedWorld)
61     , m_function(WTFMove(function))
62 {
63 }
64
65 ScheduledAction::ScheduledAction(DOMWrapperWorld& isolatedWorld, String&& code)
66     : m_isolatedWorld(isolatedWorld)
67     , m_function(isolatedWorld.vm())
68     , m_code(WTFMove(code))
69 {
70 }
71
72 ScheduledAction::~ScheduledAction() = default;
73
74 void ScheduledAction::addArguments(Vector<JSC::Strong<JSC::Unknown>>&& arguments)
75 {
76     m_arguments = WTFMove(arguments);
77 }
78
79 auto ScheduledAction::type() const -> Type
80 {
81     return m_function ? Type::Function : Type::Code;
82 }
83
84 void ScheduledAction::execute(ScriptExecutionContext& context)
85 {
86     if (is<Document>(context))
87         execute(downcast<Document>(context));
88     else
89         execute(downcast<WorkerGlobalScope>(context));
90 }
91
92 void ScheduledAction::executeFunctionInContext(JSGlobalObject* globalObject, JSValue thisValue, ScriptExecutionContext& context)
93 {
94     ASSERT(m_function);
95     VM& vm = context.vm();
96     JSLockHolder lock(vm);
97     auto scope = DECLARE_THROW_SCOPE(vm);
98
99     CallData callData;
100     CallType callType = getCallData(m_function.get(), callData);
101     if (callType == CallType::None)
102         return;
103
104     ExecState* exec = globalObject->globalExec();
105
106     MarkedArgumentBuffer arguments;
107     for (auto& argument : m_arguments)
108         arguments.append(argument.get());
109     if (UNLIKELY(arguments.hasOverflowed())) {
110         throwOutOfMemoryError(exec, scope);
111         NakedPtr<JSC::Exception> exception = scope.exception();
112         reportException(exec, exception);
113         return;
114     }
115
116     InspectorInstrumentationCookie cookie = JSMainThreadExecState::instrumentFunctionCall(&context, callType, callData);
117
118     NakedPtr<JSC::Exception> exception;
119     if (is<Document>(context))
120         JSMainThreadExecState::profiledCall(exec, JSC::ProfilingReason::Other, m_function.get(), callType, callData, thisValue, arguments, exception);
121     else
122         JSC::profiledCall(exec, JSC::ProfilingReason::Other, m_function.get(), callType, callData, thisValue, arguments, exception);
123
124     InspectorInstrumentation::didCallFunction(cookie, &context);
125
126     if (exception)
127         reportException(exec, exception);
128 }
129
130 void ScheduledAction::execute(Document& document)
131 {
132     JSDOMWindow* window = toJSDOMWindow(document.frame(), m_isolatedWorld);
133     if (!window)
134         return;
135
136     RefPtr<Frame> frame = window->wrapped().frame();
137     if (!frame || !frame->script().canExecuteScripts(AboutToExecuteScript))
138         return;
139
140     if (m_function)
141         executeFunctionInContext(window, window->proxy(), document);
142     else
143         frame->script().executeScriptInWorld(m_isolatedWorld, m_code);
144 }
145
146 void ScheduledAction::execute(WorkerGlobalScope& workerGlobalScope)
147 {
148     // In a Worker, the execution should always happen on a worker thread.
149     ASSERT(workerGlobalScope.thread().threadID() == currentThread());
150
151     WorkerScriptController* scriptController = workerGlobalScope.script();
152
153     if (m_function) {
154         JSWorkerGlobalScope* contextWrapper = scriptController->workerGlobalScopeWrapper();
155         executeFunctionInContext(contextWrapper, contextWrapper, workerGlobalScope);
156     } else {
157         ScriptSourceCode code(m_code, workerGlobalScope.url());
158         scriptController->evaluate(code);
159     }
160 }
161
162 } // namespace WebCore