62a892886d863cefaf5f493131f4320e872922cf
[WebKit-https.git] / Source / WebCore / page / DOMWindow.h
1 /*
2  * Copyright (C) 2006, 2007, 2009, 2010 Apple Inc. All rights reserved.
3  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
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 #ifndef DOMWindow_h
28 #define DOMWindow_h
29
30 #include "Base64Utilities.h"
31 #include "ContextDestructionObserver.h"
32 #include "EventTarget.h"
33 #include "FrameDestructionObserver.h"
34 #include "URL.h"
35 #include "Supplementable.h"
36 #include <functional>
37 #include <memory>
38 #include <wtf/HashSet.h>
39 #include <wtf/Optional.h>
40 #include <wtf/WeakPtr.h>
41
42 namespace Inspector {
43 class ScriptCallStack;
44 }
45
46 namespace WebCore {
47
48     class BarProp;
49     class CSSRuleList;
50     class CSSStyleDeclaration;
51     class Crypto;
52     class DOMApplicationCache;
53     class DOMSelection;
54     class DOMURL;
55     class DOMWindowProperty;
56     class DOMWrapperWorld;
57     class Database;
58     class DatabaseCallback;
59     class Document;
60     class Element;
61     class EventListener;
62     class FloatRect;
63     class Frame;
64     class History;
65     class IDBFactory;
66     class Location;
67     class MediaQueryList;
68     class MessageEvent;
69     class Navigator;
70     class Node;
71     class Page;
72     class PageConsoleClient;
73     class Performance;
74     class PostMessageTimer;
75     class ScheduledAction;
76     class Screen;
77     class SecurityOrigin;
78     class SerializedScriptValue;
79     class Storage;
80     class StyleMedia;
81     class WebKitNamespace;
82     class WebKitPoint;
83
84 #if ENABLE(REQUEST_ANIMATION_FRAME)
85     class RequestAnimationFrameCallback;
86 #endif
87
88     struct WindowFeatures;
89
90     typedef Vector<RefPtr<MessagePort>, 1> MessagePortArray;
91
92     typedef int ExceptionCode;
93
94     enum SetLocationLocking { LockHistoryBasedOnGestureState, LockHistoryAndBackForwardList };
95
96     // FIXME: DOMWindow shouldn't subclass FrameDestructionObserver and instead should get to Frame via its Document.
97     class DOMWindow final
98         : public RefCounted<DOMWindow>
99         , public EventTargetWithInlineData
100         , public ContextDestructionObserver
101         , public FrameDestructionObserver
102         , public Base64Utilities
103         , public Supplementable<DOMWindow> {
104     public:
105         static Ref<DOMWindow> create(Document* document) { return adoptRef(*new DOMWindow(document)); }
106         WEBCORE_EXPORT virtual ~DOMWindow();
107
108         // In some rare cases, we'll re-used a DOMWindow for a new Document. For example,
109         // when a script calls window.open("..."), the browser gives JavaScript a window
110         // synchronously but kicks off the load in the window asynchronously. Web sites
111         // expect that modifications that they make to the window object synchronously
112         // won't be blown away when the network load commits. To make that happen, we
113         // "securely transition" the existing DOMWindow to the Document that results from
114         // the network load. See also SecurityContext::isSecureTransitionTo.
115         void didSecureTransitionTo(Document*);
116
117         EventTargetInterface eventTargetInterface() const override { return DOMWindowEventTargetInterfaceType; }
118         ScriptExecutionContext* scriptExecutionContext() const override { return ContextDestructionObserver::scriptExecutionContext(); }
119
120         DOMWindow* toDOMWindow() override;
121
122         void registerProperty(DOMWindowProperty*);
123         void unregisterProperty(DOMWindowProperty*);
124
125         void resetUnlessSuspendedForDocumentSuspension();
126         void suspendForDocumentSuspension();
127         void resumeFromDocumentSuspension();
128
129         RefPtr<MediaQueryList> matchMedia(const String&);
130
131         WEBCORE_EXPORT unsigned pendingUnloadEventListeners() const;
132
133         WEBCORE_EXPORT static bool dispatchAllPendingBeforeUnloadEvents();
134         WEBCORE_EXPORT static void dispatchAllPendingUnloadEvents();
135
136         static FloatRect adjustWindowRect(Page*, const FloatRect& pendingChanges);
137
138         bool allowPopUp(); // Call on first window, not target window.
139         static bool allowPopUp(Frame* firstFrame);
140         static bool canShowModalDialog(const Frame*);
141         WEBCORE_EXPORT void setCanShowModalDialogOverride(bool);
142
143         // DOM Level 0
144
145         Screen* screen() const;
146         History* history() const;
147         Crypto* crypto() const;
148         BarProp* locationbar() const;
149         BarProp* menubar() const;
150         BarProp* personalbar() const;
151         BarProp* scrollbars() const;
152         BarProp* statusbar() const;
153         BarProp* toolbar() const;
154         Navigator* navigator() const;
155         Navigator* clientInformation() const { return navigator(); }
156
157         Location* location() const;
158         void setLocation(DOMWindow& activeWindow, DOMWindow& firstWindow, const String& location,
159             SetLocationLocking = LockHistoryBasedOnGestureState);
160
161         DOMSelection* getSelection();
162
163         Element* frameElement() const;
164
165         WEBCORE_EXPORT void focus(bool allowFocus = false);
166         void focus(Document&);
167         void blur();
168         WEBCORE_EXPORT void close();
169         void close(Document&);
170         void print();
171         void stop();
172
173         WEBCORE_EXPORT RefPtr<DOMWindow> open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
174             DOMWindow& activeWindow, DOMWindow& firstWindow);
175
176         void showModalDialog(const String& urlString, const String& dialogFeaturesString, DOMWindow& activeWindow, DOMWindow& firstWindow, std::function<void (DOMWindow&)> prepareDialogFunction);
177
178         void alert(const String& message);
179         bool confirm(const String& message);
180         String prompt(const String& message, const String& defaultValue);
181
182         bool find(const String&, bool caseSensitive, bool backwards, bool wrap, bool wholeWord, bool searchInFrames, bool showDialog) const;
183
184         bool offscreenBuffering() const;
185
186         int outerHeight() const;
187         int outerWidth() const;
188         int innerHeight() const;
189         int innerWidth() const;
190         int screenX() const;
191         int screenY() const;
192         int screenLeft() const { return screenX(); }
193         int screenTop() const { return screenY(); }
194         int scrollX() const;
195         int scrollY() const;
196         int pageXOffset() const { return scrollX(); }
197         int pageYOffset() const { return scrollY(); }
198
199         bool closed() const;
200
201         unsigned length() const;
202
203         String name() const;
204         void setName(const String&);
205
206         String status() const;
207         void setStatus(const String&);
208         String defaultStatus() const;
209         void setDefaultStatus(const String&);
210
211         // Self-referential attributes
212
213         DOMWindow* self() const;
214         DOMWindow* window() const { return self(); }
215         DOMWindow* frames() const { return self(); }
216
217         DOMWindow* opener() const;
218         DOMWindow* parent() const;
219         DOMWindow* top() const;
220
221         // DOM Level 2 AbstractView Interface
222
223         WEBCORE_EXPORT Document* document() const;
224
225         // CSSOM View Module
226
227         RefPtr<StyleMedia> styleMedia() const;
228
229         // DOM Level 2 Style Interface
230
231         RefPtr<CSSStyleDeclaration> getComputedStyle(Element*, const String& pseudoElt) const;
232
233         // WebKit extensions
234
235         RefPtr<CSSRuleList> getMatchedCSSRules(Element*, const String& pseudoElt, bool authorOnly = true) const;
236         double devicePixelRatio() const;
237
238         RefPtr<WebKitPoint> webkitConvertPointFromPageToNode(Node*, const WebKitPoint*) const;
239         RefPtr<WebKitPoint> webkitConvertPointFromNodeToPage(Node*, const WebKitPoint*) const;
240
241         PageConsoleClient* console() const;
242
243         void printErrorMessage(const String&);
244         String crossDomainAccessErrorMessage(const DOMWindow& activeWindow);
245
246         void postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray*, const String& targetOrigin, DOMWindow& source, ExceptionCode&);
247         // Needed for Objective-C bindings (see bug 28774).
248         void postMessage(PassRefPtr<SerializedScriptValue> message, MessagePort*, const String& targetOrigin, DOMWindow& source, ExceptionCode&);
249         void postMessageTimerFired(PostMessageTimer&);
250         void dispatchMessageEventWithOriginCheck(SecurityOrigin* intendedTargetOrigin, Event&, PassRefPtr<Inspector::ScriptCallStack>);
251
252         struct ScrollToOptions {
253             Optional<double> left;
254             Optional<double> top;
255         };
256
257         void scrollBy(const ScrollToOptions&) const;
258         void scrollBy(double x, double y) const;
259         void scrollTo(const ScrollToOptions&) const;
260         void scrollTo(double x, double y) const;
261
262         void moveBy(float x, float y) const;
263         void moveTo(float x, float y) const;
264
265         void resizeBy(float x, float y) const;
266         void resizeTo(float width, float height) const;
267
268         // Timers
269         int setTimeout(std::unique_ptr<ScheduledAction>, int timeout, ExceptionCode&);
270         void clearTimeout(int timeoutId);
271         int setInterval(std::unique_ptr<ScheduledAction>, int timeout, ExceptionCode&);
272         void clearInterval(int timeoutId);
273
274         // WebKit animation extensions
275 #if ENABLE(REQUEST_ANIMATION_FRAME)
276         int requestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback>);
277         int webkitRequestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback>);
278         void cancelAnimationFrame(int id);
279 #endif
280
281         // Events
282         // EventTarget API
283         bool addEventListener(const AtomicString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) override;
284         bool removeEventListener(const AtomicString& eventType, EventListener&, const ListenerOptions&) override;
285         void removeAllEventListeners() override;
286
287         using EventTarget::dispatchEvent;
288         bool dispatchEvent(Event&, EventTarget*);
289
290         void dispatchLoadEvent();
291
292         void captureEvents();
293         void releaseEvents();
294
295         void finishedLoading();
296
297         using RefCounted<DOMWindow>::ref;
298         using RefCounted<DOMWindow>::deref;
299
300         // HTML 5 key/value storage
301         Storage* sessionStorage(ExceptionCode&) const;
302         Storage* localStorage(ExceptionCode&) const;
303         Storage* optionalSessionStorage() const { return m_sessionStorage.get(); }
304         Storage* optionalLocalStorage() const { return m_localStorage.get(); }
305
306         DOMApplicationCache* applicationCache() const;
307         DOMApplicationCache* optionalApplicationCache() const { return m_applicationCache.get(); }
308
309 #if ENABLE(ORIENTATION_EVENTS)
310         // This is the interface orientation in degrees. Some examples are:
311         //  0 is straight up; -90 is when the device is rotated 90 clockwise;
312         //  90 is when rotated counter clockwise.
313         int orientation() const;
314 #endif
315
316 #if ENABLE(WEB_TIMING)
317         Performance* performance() const;
318 #endif
319
320 #if PLATFORM(IOS)
321         void incrementScrollEventListenersCount();
322         void decrementScrollEventListenersCount();
323         unsigned scrollEventListenerCount() const { return m_scrollEventListenerCount; }
324 #endif
325
326         void resetAllGeolocationPermission();
327
328 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
329         bool hasTouchEventListeners() const { return m_touchEventListenerCount > 0; }
330 #endif
331
332 #if ENABLE(USER_MESSAGE_HANDLERS)
333         bool shouldHaveWebKitNamespaceForWorld(DOMWrapperWorld&);
334         WebKitNamespace* webkitNamespace() const;
335 #endif
336
337         // FIXME: When this DOMWindow is no longer the active DOMWindow (i.e.,
338         // when its document is no longer the document that is displayed in its
339         // frame), we would like to zero out m_frame to avoid being confused
340         // by the document that is currently active in m_frame.
341         bool isCurrentlyDisplayedInFrame() const;
342
343         void willDetachDocumentFromFrame();
344         void willDestroyCachedFrame();
345
346         void enableSuddenTermination();
347         void disableSuddenTermination();
348
349         WeakPtr<DOMWindow> createWeakPtr() { return m_weakPtrFactory.createWeakPtr(); }
350
351     private:
352         explicit DOMWindow(Document*);
353
354         Page* page();
355         bool allowedToChangeWindowGeometry() const;
356
357         void frameDestroyed() override;
358         void willDetachPage() override;
359
360         void refEventTarget() override { ref(); }
361         void derefEventTarget() override { deref(); }
362
363         static RefPtr<Frame> createWindow(const String& urlString, const AtomicString& frameName, const WindowFeatures&, DOMWindow& activeWindow, Frame& firstFrame, Frame& openerFrame, std::function<void (DOMWindow&)> prepareDialogFunction = nullptr);
364         bool isInsecureScriptAccess(DOMWindow& activeWindow, const String& urlString);
365
366         void resetDOMWindowProperties();
367         void disconnectDOMWindowProperties();
368         void reconnectDOMWindowProperties();
369         void willDestroyDocumentInFrame();
370
371         bool isSameSecurityOriginAsMainFrame() const;
372
373 #if ENABLE(GAMEPAD)
374         void incrementGamepadEventListenerCount();
375         void decrementGamepadEventListenerCount();
376 #endif
377
378         bool m_shouldPrintWhenFinishedLoading;
379         bool m_suspendedForDocumentSuspension;
380         Optional<bool> m_canShowModalDialogOverride;
381
382         HashSet<DOMWindowProperty*> m_properties;
383
384         mutable RefPtr<Screen> m_screen;
385         mutable RefPtr<History> m_history;
386         mutable RefPtr<Crypto>  m_crypto;
387         mutable RefPtr<BarProp> m_locationbar;
388         mutable RefPtr<BarProp> m_menubar;
389         mutable RefPtr<BarProp> m_personalbar;
390         mutable RefPtr<BarProp> m_scrollbars;
391         mutable RefPtr<BarProp> m_statusbar;
392         mutable RefPtr<BarProp> m_toolbar;
393         mutable RefPtr<Navigator> m_navigator;
394         mutable RefPtr<Location> m_location;
395         mutable RefPtr<StyleMedia> m_media;
396
397         String m_status;
398         String m_defaultStatus;
399
400         enum PageStatus { PageStatusNone, PageStatusShown, PageStatusHidden };
401         PageStatus m_lastPageStatus;
402
403         WeakPtrFactory<DOMWindow> m_weakPtrFactory;
404
405 #if PLATFORM(IOS)
406         unsigned m_scrollEventListenerCount;
407 #endif
408
409 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
410         unsigned m_touchEventListenerCount;
411 #endif
412
413 #if ENABLE(GAMEPAD)
414         unsigned m_gamepadEventListenerCount;
415 #endif
416         mutable RefPtr<Storage> m_sessionStorage;
417         mutable RefPtr<Storage> m_localStorage;
418         mutable RefPtr<DOMApplicationCache> m_applicationCache;
419
420 #if ENABLE(WEB_TIMING)
421         mutable RefPtr<Performance> m_performance;
422 #endif
423
424 #if ENABLE(USER_MESSAGE_HANDLERS)
425         mutable RefPtr<WebKitNamespace> m_webkitNamespace;
426 #endif
427     };
428
429     inline String DOMWindow::status() const
430     {
431         return m_status;
432     }
433
434     inline String DOMWindow::defaultStatus() const
435     {
436         return m_defaultStatus;
437     }
438
439 } // namespace WebCore
440
441 #endif // DOMWindow_h