61e4b58e00f43d0bfa58a066f7e845910efc0fd2
[WebKit-https.git] / Source / WebCore / dom / ScriptExecutionContext.h
1 /*
2  * Copyright (C) 2008 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 COMPUTER, 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 COMPUTER, 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 #ifndef ScriptExecutionContext_h
29 #define ScriptExecutionContext_h
30
31 #include "ActiveDOMObject.h"
32 #include "ConsoleTypes.h"
33 #include "KURL.h"
34 #include "ScriptCallStack.h"
35 #include "ScriptState.h"
36 #include "SecurityContext.h"
37 #include "Supplementable.h"
38 #include <wtf/Forward.h>
39 #include <wtf/HashMap.h>
40 #include <wtf/HashSet.h>
41 #include <wtf/Noncopyable.h>
42 #include <wtf/OwnPtr.h>
43 #include <wtf/PassOwnPtr.h>
44 #include <wtf/Threading.h>
45 #include <wtf/text/StringHash.h>
46
47 #if USE(JSC)
48 #include <runtime/JSGlobalData.h>
49 #endif
50
51 namespace WebCore {
52
53 class CachedScript;
54 class DatabaseContext;
55 class DOMTimer;
56 class EventListener;
57 class EventQueue;
58 class EventTarget;
59 class MessagePort;
60
61 #if ENABLE(BLOB)
62 class PublicURLManager;
63 #endif
64
65 #if ENABLE(BLOB)
66 class FileThread;
67 #endif
68
69 class ScriptExecutionContext : public SecurityContext, public Supplementable<ScriptExecutionContext> {
70 public:
71     ScriptExecutionContext();
72     virtual ~ScriptExecutionContext();
73
74     virtual bool isDocument() const { return false; }
75     virtual bool isWorkerContext() const { return false; }
76
77     virtual bool isContextThread() const { return true; }
78     virtual bool isJSExecutionForbidden() const = 0;
79
80     const KURL& url() const { return virtualURL(); }
81     KURL completeURL(const String& url) const { return virtualCompleteURL(url); }
82
83     virtual String userAgent(const KURL&) const = 0;
84
85     virtual void disableEval(const String& errorMessage) = 0;
86
87     bool sanitizeScriptError(String& errorMessage, int& lineNumber, String& sourceURL, CachedScript* = 0);
88     void reportException(const String& errorMessage, int lineNumber, const String& sourceURL, PassRefPtr<ScriptCallStack>, CachedScript* = 0);
89
90     void addConsoleMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, ScriptState* = 0, unsigned long requestIdentifier = 0);
91     virtual void addConsoleMessage(MessageSource, MessageLevel, const String& message, unsigned long requestIdentifier = 0) = 0;
92
93     virtual const SecurityOrigin* topOrigin() const = 0;
94
95 #if ENABLE(BLOB)
96     PublicURLManager& publicURLManager();
97 #endif
98     // Active objects are not garbage collected even if inaccessible, e.g. because their activity may result in callbacks being invoked.
99     bool canSuspendActiveDOMObjects();
100     // Active objects can be asked to suspend even if canSuspendActiveDOMObjects() returns 'false' -
101     // step-by-step JS debugging is one example.
102     virtual void suspendActiveDOMObjects(ActiveDOMObject::ReasonForSuspension);
103     virtual void resumeActiveDOMObjects();
104     virtual void stopActiveDOMObjects();
105
106     bool activeDOMObjectsAreSuspended() const { return m_activeDOMObjectsAreSuspended; }
107     bool activeDOMObjectsAreStopped() const { return m_activeDOMObjectsAreStopped; }
108
109     // Called from the constructor and destructors of ActiveDOMObject.
110     void didCreateActiveDOMObject(ActiveDOMObject*, void* upcastPointer);
111     void willDestroyActiveDOMObject(ActiveDOMObject*);
112
113     // Called after the construction of an ActiveDOMObject to synchronize suspend state.
114     void suspendActiveDOMObjectIfNeeded(ActiveDOMObject*);
115
116     typedef const HashMap<ActiveDOMObject*, void*> ActiveDOMObjectsMap;
117     ActiveDOMObjectsMap& activeDOMObjects() const { return m_activeDOMObjects; }
118
119     void didCreateDestructionObserver(ContextDestructionObserver*);
120     void willDestroyDestructionObserver(ContextDestructionObserver*);
121
122     virtual void suspendScriptedAnimationControllerCallbacks() { }
123     virtual void resumeScriptedAnimationControllerCallbacks() { }
124
125     // MessagePort is conceptually a kind of ActiveDOMObject, but it needs to be tracked separately for message dispatch.
126     void processMessagePortMessagesSoon();
127     void dispatchMessagePortEvents();
128     void createdMessagePort(MessagePort*);
129     void destroyedMessagePort(MessagePort*);
130     const HashSet<MessagePort*>& messagePorts() const { return m_messagePorts; }
131
132     void ref() { refScriptExecutionContext(); }
133     void deref() { derefScriptExecutionContext(); }
134
135     class Task {
136         WTF_MAKE_NONCOPYABLE(Task);
137         WTF_MAKE_FAST_ALLOCATED;
138     public:
139         Task() { }
140         virtual ~Task();
141         virtual void performTask(ScriptExecutionContext*) = 0;
142         // Certain tasks get marked specially so that they aren't discarded, and are executed, when the context is shutting down its message queue.
143         virtual bool isCleanupTask() const { return false; }
144     };
145
146     virtual void postTask(PassOwnPtr<Task>) = 0; // Executes the task on context's thread asynchronously.
147
148     // Gets the next id in a circular sequence from 1 to 2^31-1.
149     int circularSequentialID();
150
151     bool addTimeout(int timeoutId, DOMTimer* timer) { return m_timeouts.add(timeoutId, timer).isNewEntry; }
152     void removeTimeout(int timeoutId) { m_timeouts.remove(timeoutId); }
153     DOMTimer* findTimeout(int timeoutId) { return m_timeouts.get(timeoutId); }
154
155 #if USE(JSC)
156     JSC::JSGlobalData* globalData();
157 #endif
158
159 #if ENABLE(BLOB)
160     FileThread* fileThread();
161     void stopFileThread();
162 #endif
163
164     // Interval is in seconds.
165     void adjustMinimumTimerInterval(double oldMinimumTimerInterval);
166     virtual double minimumTimerInterval() const;
167
168     void didChangeTimerAlignmentInterval();
169     virtual double timerAlignmentInterval() const;
170
171     virtual EventQueue* eventQueue() const = 0;
172
173     virtual void reportMemoryUsage(MemoryObjectInfo*) const OVERRIDE;
174
175 #if ENABLE(SQL_DATABASE)
176     void setDatabaseContext(DatabaseContext*);
177 #endif
178
179 protected:
180     class AddConsoleMessageTask : public Task {
181     public:
182         static PassOwnPtr<AddConsoleMessageTask> create(MessageSource source, MessageLevel level, const String& message)
183         {
184             return adoptPtr(new AddConsoleMessageTask(source, level, message));
185         }
186         virtual void performTask(ScriptExecutionContext*);
187     private:
188         AddConsoleMessageTask(MessageSource source, MessageLevel level, const String& message)
189             : m_source(source)
190             , m_level(level)
191             , m_message(message.isolatedCopy())
192         {
193         }
194         MessageSource m_source;
195         MessageLevel m_level;
196         String m_message;
197     };
198
199 private:
200     virtual const KURL& virtualURL() const = 0;
201     virtual KURL virtualCompleteURL(const String&) const = 0;
202
203     virtual void addMessage(MessageSource, MessageLevel, const String& message, const String& sourceURL, unsigned lineNumber, PassRefPtr<ScriptCallStack>, ScriptState* = 0, unsigned long requestIdentifier = 0) = 0;
204     virtual EventTarget* errorEventTarget() = 0;
205     virtual void logExceptionToConsole(const String& errorMessage, const String& sourceURL, int lineNumber, PassRefPtr<ScriptCallStack>) = 0;
206     bool dispatchErrorEvent(const String& errorMessage, int lineNumber, const String& sourceURL, CachedScript*);
207
208     void closeMessagePorts();
209
210     virtual void refScriptExecutionContext() = 0;
211     virtual void derefScriptExecutionContext() = 0;
212
213     HashSet<MessagePort*> m_messagePorts;
214     HashSet<ContextDestructionObserver*> m_destructionObservers;
215     HashMap<ActiveDOMObject*, void*> m_activeDOMObjects;
216     bool m_iteratingActiveDOMObjects;
217     bool m_inDestructor;
218
219     int m_circularSequentialID;
220     typedef HashMap<int, DOMTimer*> TimeoutMap;
221     TimeoutMap m_timeouts;
222
223     bool m_inDispatchErrorEvent;
224     class PendingException;
225     OwnPtr<Vector<OwnPtr<PendingException> > > m_pendingExceptions;
226
227     bool m_activeDOMObjectsAreSuspended;
228     ActiveDOMObject::ReasonForSuspension m_reasonForSuspendingActiveDOMObjects;
229     bool m_activeDOMObjectsAreStopped;
230
231 #if ENABLE(BLOB)
232     OwnPtr<PublicURLManager> m_publicURLManager;
233     RefPtr<FileThread> m_fileThread;
234 #endif
235
236 #if ENABLE(SQL_DATABASE)
237     RefPtr<DatabaseContext> m_databaseContext;
238 #endif
239 };
240
241 } // namespace WebCore
242
243 #endif // ScriptExecutionContext_h