Support container.getRegistration() / getRegistrations() inside service workers
[WebKit-https.git] / Source / WebCore / dom / ScriptExecutionContext.h
1 /*
2  * Copyright (C) 2008-2017 Apple Inc. All Rights Reserved.
3  * Copyright (C) 2012 Google Inc. All Rights Reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  */
27
28 #pragma once
29
30 #include "ActiveDOMObject.h"
31 #include "DOMTimer.h"
32 #include "SecurityContext.h"
33 #include "ServiceWorkerTypes.h"
34 #include <heap/HandleTypes.h>
35 #include <runtime/ConsoleTypes.h>
36 #include <wtf/CrossThreadTask.h>
37 #include <wtf/Function.h>
38 #include <wtf/HashSet.h>
39 #include <wtf/text/WTFString.h>
40
41 namespace JSC {
42 class Exception;
43 class ExecState;
44 class JSPromise;
45 class VM;
46 template<typename> class Strong;
47 }
48
49 namespace Inspector {
50 class ConsoleMessage;
51 class ScriptCallStack;
52 }
53
54 namespace PAL {
55 class SessionID;
56 }
57
58 namespace WebCore {
59
60 class CachedScript;
61 class DatabaseContext;
62 class EventQueue;
63 class EventTarget;
64 class MessagePort;
65 class PublicURLManager;
66 class RejectedPromiseTracker;
67 class ResourceRequest;
68 class SecurityOrigin;
69 class SocketProvider;
70 class URL;
71
72 #if ENABLE(SERVICE_WORKER)
73 class ServiceWorker;
74 class ServiceWorkerContainer;
75 #endif
76
77 namespace IDBClient {
78 class IDBConnectionProxy;
79 }
80
81 class ScriptExecutionContext : public SecurityContext {
82 public:
83     ScriptExecutionContext();
84     virtual ~ScriptExecutionContext();
85
86     virtual bool isDocument() const { return false; }
87     virtual bool isWorkerGlobalScope() const { return false; }
88
89     virtual bool isContextThread() const { return true; }
90     virtual bool isJSExecutionForbidden() const = 0;
91
92     virtual const URL& url() const = 0;
93     virtual URL completeURL(const String& url) const = 0;
94     virtual PAL::SessionID sessionID() const = 0;
95
96     virtual String userAgent(const URL&) const = 0;
97
98     virtual void disableEval(const String& errorMessage) = 0;
99     virtual void disableWebAssembly(const String& errorMessage) = 0;
100
101 #if ENABLE(INDEXED_DATABASE)
102     virtual IDBClient::IDBConnectionProxy* idbConnectionProxy() = 0;
103 #endif
104     virtual SocketProvider* socketProvider() = 0;
105
106     virtual String resourceRequestIdentifier() const { return String(); };
107
108     bool sanitizeScriptError(String& errorMessage, int& lineNumber, int& columnNumber, String& sourceURL, JSC::Strong<JSC::Unknown>& error, CachedScript* = nullptr);
109     void reportException(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL, JSC::Exception*, RefPtr<Inspector::ScriptCallStack>&&, CachedScript* = nullptr);
110     void reportUnhandledPromiseRejection(JSC::ExecState&, JSC::JSPromise&, RefPtr<Inspector::ScriptCallStack>&&);
111
112     virtual void addConsoleMessage(std::unique_ptr<Inspector::ConsoleMessage>&&) = 0;
113
114     // The following addConsoleMessage functions are deprecated.
115     // Callers should try to create the ConsoleMessage themselves.
116     void addConsoleMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, JSC::ExecState* = nullptr, unsigned long requestIdentifier = 0);
117     virtual void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier = 0) = 0;
118
119     virtual SecurityOrigin& topOrigin() const = 0;
120     virtual String origin() const = 0;
121
122     virtual bool shouldBypassMainWorldContentSecurityPolicy() const { return false; }
123
124     PublicURLManager& publicURLManager();
125
126     // Active objects are not garbage collected even if inaccessible, e.g. because their activity may result in callbacks being invoked.
127     WEBCORE_EXPORT bool canSuspendActiveDOMObjectsForDocumentSuspension(Vector<ActiveDOMObject*>* unsuspendableObjects = nullptr);
128
129     // Active objects can be asked to suspend even if canSuspendActiveDOMObjectsForDocumentSuspension() returns 'false' -
130     // step-by-step JS debugging is one example.
131     virtual void suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension);
132     virtual void resumeActiveDOMObjects(ActiveDOMObject::ReasonForSuspension);
133     virtual void stopActiveDOMObjects();
134
135     bool activeDOMObjectsAreSuspended() const { return m_activeDOMObjectsAreSuspended; }
136     bool activeDOMObjectsAreStopped() const { return m_activeDOMObjectsAreStopped; }
137
138     // Called from the constructor and destructors of ActiveDOMObject.
139     void didCreateActiveDOMObject(ActiveDOMObject&);
140     void willDestroyActiveDOMObject(ActiveDOMObject&);
141
142     // Called after the construction of an ActiveDOMObject to synchronize suspend state.
143     void suspendActiveDOMObjectIfNeeded(ActiveDOMObject&);
144
145     void didCreateDestructionObserver(ContextDestructionObserver&);
146     void willDestroyDestructionObserver(ContextDestructionObserver&);
147
148     // MessagePort is conceptually a kind of ActiveDOMObject, but it needs to be tracked separately for message dispatch.
149     void processMessagePortMessagesSoon();
150     void dispatchMessagePortEvents();
151     void createdMessagePort(MessagePort&);
152     void destroyedMessagePort(MessagePort&);
153
154     virtual void didLoadResourceSynchronously();
155
156     void ref() { refScriptExecutionContext(); }
157     void deref() { derefScriptExecutionContext(); }
158
159     class Task {
160         WTF_MAKE_FAST_ALLOCATED;
161     public:
162         enum CleanupTaskTag { CleanupTask };
163
164         template<typename T, typename = typename std::enable_if<!std::is_base_of<Task, T>::value && std::is_convertible<T, WTF::Function<void (ScriptExecutionContext&)>>::value>::type>
165         Task(T task)
166             : m_task(WTFMove(task))
167             , m_isCleanupTask(false)
168         {
169         }
170
171         Task(WTF::Function<void ()>&& task)
172             : m_task([task = WTFMove(task)](ScriptExecutionContext&) { task(); })
173             , m_isCleanupTask(false)
174         {
175         }
176
177         template<typename T, typename = typename std::enable_if<std::is_convertible<T, WTF::Function<void (ScriptExecutionContext&)>>::value>::type>
178         Task(CleanupTaskTag, T task)
179             : m_task(WTFMove(task))
180             , m_isCleanupTask(true)
181         {
182         }
183
184         void performTask(ScriptExecutionContext& context) { m_task(context); }
185         bool isCleanupTask() const { return m_isCleanupTask; }
186
187     protected:
188         WTF::Function<void (ScriptExecutionContext&)> m_task;
189         bool m_isCleanupTask;
190     };
191
192     virtual void postTask(Task&&) = 0; // Executes the task on context's thread asynchronously.
193
194     template<typename... Arguments>
195     void postCrossThreadTask(Arguments&&... arguments)
196     {
197         postTask([crossThreadTask = createCrossThreadTask(arguments...)](ScriptExecutionContext&) mutable {
198             crossThreadTask.performTask();
199         });
200     }
201
202     // Gets the next id in a circular sequence from 1 to 2^31-1.
203     int circularSequentialID();
204
205     bool addTimeout(int timeoutId, DOMTimer& timer) { return m_timeouts.add(timeoutId, &timer).isNewEntry; }
206     void removeTimeout(int timeoutId) { m_timeouts.remove(timeoutId); }
207     DOMTimer* findTimeout(int timeoutId) { return m_timeouts.get(timeoutId); }
208
209     WEBCORE_EXPORT JSC::VM& vm();
210
211     void adjustMinimumDOMTimerInterval(Seconds oldMinimumTimerInterval);
212     virtual Seconds minimumDOMTimerInterval() const;
213
214     void didChangeTimerAlignmentInterval();
215     virtual Seconds domTimerAlignmentInterval(bool hasReachedMaxNestingLevel) const;
216
217     virtual EventQueue& eventQueue() const = 0;
218     virtual EventTarget* errorEventTarget() = 0;
219
220     DatabaseContext* databaseContext() { return m_databaseContext.get(); }
221     void setDatabaseContext(DatabaseContext*);
222
223 #if ENABLE(SUBTLE_CRYPTO)
224     virtual bool wrapCryptoKey(const Vector<uint8_t>& key, Vector<uint8_t>& wrappedKey) = 0;
225     virtual bool unwrapCryptoKey(const Vector<uint8_t>& wrappedKey, Vector<uint8_t>& key) = 0;
226 #endif
227
228     int timerNestingLevel() const { return m_timerNestingLevel; }
229     void setTimerNestingLevel(int timerNestingLevel) { m_timerNestingLevel = timerNestingLevel; }
230
231     RejectedPromiseTracker& ensureRejectedPromiseTracker()
232     {
233         if (m_rejectedPromiseTracker)
234             return *m_rejectedPromiseTracker.get();
235         return ensureRejectedPromiseTrackerSlow();
236     }
237
238     JSC::ExecState* execState();
239
240 #if ENABLE(SERVICE_WORKER)
241     ServiceWorker* activeServiceWorker() const;
242     void setActiveServiceWorker(RefPtr<ServiceWorker>&&);
243
244     void registerServiceWorker(ServiceWorker&);
245     void unregisterServiceWorker(ServiceWorker&);
246     ServiceWorker* serviceWorker(ServiceWorkerIdentifier identifier) { return m_serviceWorkers.get(identifier); }
247
248     ServiceWorkerContainer* serviceWorkerContainer();
249
250     WEBCORE_EXPORT static void postTaskTo(const DocumentOrWorkerIdentifier&, WTF::Function<void(ScriptExecutionContext&)>&&);
251 #endif
252
253 protected:
254     class AddConsoleMessageTask : public Task {
255     public:
256         AddConsoleMessageTask(std::unique_ptr<Inspector::ConsoleMessage>&& consoleMessage)
257             : Task([&consoleMessage](ScriptExecutionContext& context) {
258                 context.addConsoleMessage(WTFMove(consoleMessage));
259             })
260         {
261         }
262
263         AddConsoleMessageTask(MessageSource source, MessageLevel level, const String& message)
264             : Task([source, level, message = message.isolatedCopy()](ScriptExecutionContext& context) {
265                 context.addConsoleMessage(source, level, message);
266             })
267         {
268         }
269     };
270
271     ActiveDOMObject::ReasonForSuspension reasonForSuspendingActiveDOMObjects() const { return m_reasonForSuspendingActiveDOMObjects; }
272
273     bool hasPendingActivity() const;
274
275 private:
276     // The following addMessage function is deprecated.
277     // Callers should try to create the ConsoleMessage themselves.
278     virtual void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, unsigned columnNumber, RefPtr<Inspector::ScriptCallStack>&&, JSC::ExecState* = nullptr, unsigned long requestIdentifier = 0) = 0;
279     virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, int columnNumber, RefPtr<Inspector::ScriptCallStack>&&) = 0;
280     bool dispatchErrorEvent(const String& errorMessage, int lineNumber, int columnNumber, const String& sourceURL, JSC::Exception*, CachedScript*);
281
282     virtual void refScriptExecutionContext() = 0;
283     virtual void derefScriptExecutionContext() = 0;
284
285     RejectedPromiseTracker& ensureRejectedPromiseTrackerSlow();
286
287     void checkConsistency() const;
288
289     HashSet<MessagePort*> m_messagePorts;
290     HashSet<ContextDestructionObserver*> m_destructionObservers;
291     HashSet<ActiveDOMObject*> m_activeDOMObjects;
292
293     HashMap<int, RefPtr<DOMTimer>> m_timeouts;
294
295     struct PendingException;
296     std::unique_ptr<Vector<std::unique_ptr<PendingException>>> m_pendingExceptions;
297     std::unique_ptr<RejectedPromiseTracker> m_rejectedPromiseTracker;
298
299     ActiveDOMObject::ReasonForSuspension m_reasonForSuspendingActiveDOMObjects { static_cast<ActiveDOMObject::ReasonForSuspension>(-1) };
300
301     std::unique_ptr<PublicURLManager> m_publicURLManager;
302
303     RefPtr<DatabaseContext> m_databaseContext;
304
305     int m_circularSequentialID { 0 };
306     int m_timerNestingLevel { 0 };
307
308     bool m_activeDOMObjectsAreSuspended { false };
309     bool m_activeDOMObjectsAreStopped { false };
310     bool m_inDispatchErrorEvent { false };
311     bool m_activeDOMObjectAdditionForbidden { false };
312     bool m_willProcessMessagePortMessagesSoon { false };
313
314 #if !ASSERT_DISABLED
315     bool m_inScriptExecutionContextDestructor { false };
316 #endif
317 #if !ASSERT_DISABLED || ENABLE(SECURITY_ASSERTIONS)
318     bool m_activeDOMObjectRemovalForbidden { false };
319 #endif
320
321 #if ENABLE(SERVICE_WORKER)
322     RefPtr<ServiceWorker> m_activeServiceWorker;
323     HashMap<ServiceWorkerIdentifier, ServiceWorker*> m_serviceWorkers;
324 #endif
325 };
326
327 } // namespace WebCore