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