Use "= default" to denote default constructor or destructor
[WebKit-https.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, 2004, 2005, 2006, 2007, 2008, 2009 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     JSLockHolder lock(context.vm());
96
97     CallData callData;
98     CallType callType = getCallData(m_function.get(), callData);
99     if (callType == CallType::None)
100         return;
101
102     ExecState* exec = globalObject->globalExec();
103
104     MarkedArgumentBuffer arguments;
105     for (auto& argument : m_arguments)
106         arguments.append(argument.get());
107
108     InspectorInstrumentationCookie cookie = JSMainThreadExecState::instrumentFunctionCall(&context, callType, callData);
109
110     NakedPtr<JSC::Exception> exception;
111     if (is<Document>(context))
112         JSMainThreadExecState::profiledCall(exec, JSC::ProfilingReason::Other, m_function.get(), callType, callData, thisValue, arguments, exception);
113     else
114         JSC::profiledCall(exec, JSC::ProfilingReason::Other, m_function.get(), callType, callData, thisValue, arguments, exception);
115
116     InspectorInstrumentation::didCallFunction(cookie, &context);
117
118     if (exception)
119         reportException(exec, exception);
120 }
121
122 void ScheduledAction::execute(Document& document)
123 {
124     JSDOMWindow* window = toJSDOMWindow(document.frame(), m_isolatedWorld);
125     if (!window)
126         return;
127
128     RefPtr<Frame> frame = window->wrapped().frame();
129     if (!frame || !frame->script().canExecuteScripts(AboutToExecuteScript))
130         return;
131
132     if (m_function)
133         executeFunctionInContext(window, window->proxy(), document);
134     else
135         frame->script().executeScriptInWorld(m_isolatedWorld, m_code);
136 }
137
138 void ScheduledAction::execute(WorkerGlobalScope& workerGlobalScope)
139 {
140     // In a Worker, the execution should always happen on a worker thread.
141     ASSERT(workerGlobalScope.thread().threadID() == currentThread());
142
143     WorkerScriptController* scriptController = workerGlobalScope.script();
144
145     if (m_function) {
146         JSWorkerGlobalScope* contextWrapper = scriptController->workerGlobalScopeWrapper();
147         executeFunctionInContext(contextWrapper, contextWrapper, workerGlobalScope);
148     } else {
149         ScriptSourceCode code(m_code, workerGlobalScope.url());
150         scriptController->evaluate(code);
151     }
152 }
153
154 } // namespace WebCore