Move cross-port Source/WebCore/page/ code to std::unique_ptr
[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
37 namespace Inspector {
38 class ScriptCallStack;
39 }
40
41 namespace WebCore {
42
43     class BarProp;
44     class CSSRuleList;
45     class CSSStyleDeclaration;
46     class Crypto;
47     class DOMApplicationCache;
48     class DOMSelection;
49     class DOMURL;
50     class DOMWindowProperty;
51     class Database;
52     class DatabaseCallback;
53     class Document;
54     class Element;
55     class EventListener;
56     class FloatRect;
57     class Frame;
58     class History;
59     class IDBFactory;
60     class Location;
61     class MediaQueryList;
62     class MessageEvent;
63     class Navigator;
64     class Node;
65     class Page;
66     class PageConsole;
67     class Performance;
68     class PostMessageTimer;
69     class ScheduledAction;
70     class Screen;
71     class SecurityOrigin;
72     class SerializedScriptValue;
73     class Storage;
74     class StyleMedia;
75     class WebKitPoint;
76     class DOMWindowCSS;
77
78 #if ENABLE(REQUEST_ANIMATION_FRAME)
79     class RequestAnimationFrameCallback;
80 #endif
81
82     struct WindowFeatures;
83
84     typedef Vector<RefPtr<MessagePort>, 1> MessagePortArray;
85
86     typedef int ExceptionCode;
87
88     enum SetLocationLocking { LockHistoryBasedOnGestureState, LockHistoryAndBackForwardList };
89
90     // FIXME: DOMWindow shouldn't subclass FrameDestructionObserver and instead should get to Frame via its Document.
91     class DOMWindow final
92         : public RefCounted<DOMWindow>
93         , public EventTargetWithInlineData
94         , public ContextDestructionObserver
95         , public FrameDestructionObserver
96         , public Supplementable<DOMWindow> {
97     public:
98         static PassRefPtr<DOMWindow> create(Document* document) { return adoptRef(new DOMWindow(document)); }
99         virtual ~DOMWindow();
100
101         // In some rare cases, we'll re-used a DOMWindow for a new Document. For example,
102         // when a script calls window.open("..."), the browser gives JavaScript a window
103         // synchronously but kicks off the load in the window asynchronously. Web sites
104         // expect that modifications that they make to the window object synchronously
105         // won't be blown away when the network load commits. To make that happen, we
106         // "securely transition" the existing DOMWindow to the Document that results from
107         // the network load. See also SecurityContext::isSecureTransitionTo.
108         void didSecureTransitionTo(Document*);
109
110         virtual EventTargetInterface eventTargetInterface() const override { return DOMWindowEventTargetInterfaceType; }
111         virtual ScriptExecutionContext* scriptExecutionContext() const override { return ContextDestructionObserver::scriptExecutionContext(); }
112
113         virtual DOMWindow* toDOMWindow() override;
114
115         void registerProperty(DOMWindowProperty*);
116         void unregisterProperty(DOMWindowProperty*);
117
118         void resetUnlessSuspendedForPageCache();
119         void suspendForPageCache();
120         void resumeFromPageCache();
121
122         PassRefPtr<MediaQueryList> matchMedia(const String&);
123
124         unsigned pendingUnloadEventListeners() const;
125
126         static bool dispatchAllPendingBeforeUnloadEvents();
127         static void dispatchAllPendingUnloadEvents();
128
129         static FloatRect adjustWindowRect(Page*, const FloatRect& pendingChanges);
130
131         bool allowPopUp(); // Call on first window, not target window.
132         static bool allowPopUp(Frame* firstFrame);
133         static bool canShowModalDialog(const Frame*);
134         static bool canShowModalDialogNow(const Frame*);
135
136         // DOM Level 0
137
138         Screen* screen() const;
139         History* history() const;
140         Crypto* crypto() const;
141         BarProp* locationbar() const;
142         BarProp* menubar() const;
143         BarProp* personalbar() const;
144         BarProp* scrollbars() const;
145         BarProp* statusbar() const;
146         BarProp* toolbar() const;
147         Navigator* navigator() const;
148         Navigator* clientInformation() const { return navigator(); }
149
150         Location* location() const;
151         void setLocation(const String& location, DOMWindow& activeWindow, DOMWindow& firstWindow,
152             SetLocationLocking = LockHistoryBasedOnGestureState);
153
154         DOMSelection* getSelection();
155
156         Element* frameElement() const;
157
158         void focus(ScriptExecutionContext* = 0);
159         void blur();
160         void close(ScriptExecutionContext* = 0);
161         void print();
162         void stop();
163
164         PassRefPtr<DOMWindow> open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
165             DOMWindow& activeWindow, DOMWindow& firstWindow);
166
167         void showModalDialog(const String& urlString, const String& dialogFeaturesString, DOMWindow& activeWindow, DOMWindow& firstWindow, std::function<void (DOMWindow&)> prepareDialogFunction);
168
169         void alert(const String& message);
170         bool confirm(const String& message);
171         String prompt(const String& message, const String& defaultValue);
172         String btoa(const String& stringToEncode, ExceptionCode&);
173         String atob(const String& encodedString, ExceptionCode&);
174
175         bool find(const String&, bool caseSensitive, bool backwards, bool wrap, bool wholeWord, bool searchInFrames, bool showDialog) const;
176
177         bool offscreenBuffering() const;
178
179         int outerHeight() const;
180         int outerWidth() const;
181         int innerHeight() const;
182         int innerWidth() const;
183         int screenX() const;
184         int screenY() const;
185         int screenLeft() const { return screenX(); }
186         int screenTop() const { return screenY(); }
187         int scrollX() const;
188         int scrollY() const;
189         int pageXOffset() const { return scrollX(); }
190         int pageYOffset() const { return scrollY(); }
191
192         bool closed() const;
193
194         unsigned length() const;
195
196         String name() const;
197         void setName(const String&);
198
199         String status() const;
200         void setStatus(const String&);
201         String defaultStatus() const;
202         void setDefaultStatus(const String&);
203
204         // Self-referential attributes
205
206         DOMWindow* self() const;
207         DOMWindow* window() const { return self(); }
208         DOMWindow* frames() const { return self(); }
209
210         DOMWindow* opener() const;
211         DOMWindow* parent() const;
212         DOMWindow* top() const;
213
214         // DOM Level 2 AbstractView Interface
215
216         Document* document() const;
217
218         // CSSOM View Module
219
220         PassRefPtr<StyleMedia> styleMedia() const;
221
222         // DOM Level 2 Style Interface
223
224         PassRefPtr<CSSStyleDeclaration> getComputedStyle(Element*, const String& pseudoElt) const;
225
226         // WebKit extensions
227
228         PassRefPtr<CSSRuleList> getMatchedCSSRules(Element*, const String& pseudoElt, bool authorOnly = true) const;
229         double devicePixelRatio() const;
230
231         PassRefPtr<WebKitPoint> webkitConvertPointFromPageToNode(Node*, const WebKitPoint*) const;
232         PassRefPtr<WebKitPoint> webkitConvertPointFromNodeToPage(Node*, const WebKitPoint*) const;
233
234         PageConsole* pageConsole() const;
235
236         void printErrorMessage(const String&);
237         String crossDomainAccessErrorMessage(const DOMWindow& activeWindow);
238
239         void postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray*, const String& targetOrigin, DOMWindow& source, ExceptionCode&);
240         // Needed for Objective-C bindings (see bug 28774).
241         void postMessage(PassRefPtr<SerializedScriptValue> message, MessagePort*, const String& targetOrigin, DOMWindow& source, ExceptionCode&);
242         void postMessageTimerFired(PostMessageTimer&);
243         void dispatchMessageEventWithOriginCheck(SecurityOrigin* intendedTargetOrigin, PassRefPtr<Event>, PassRefPtr<Inspector::ScriptCallStack>);
244
245         void scrollBy(int x, int y) const;
246         void scrollTo(int x, int y) const;
247         void scroll(int x, int y) const { scrollTo(x, y); }
248
249         void moveBy(float x, float y) const;
250         void moveTo(float x, float y) const;
251
252         void resizeBy(float x, float y) const;
253         void resizeTo(float width, float height) const;
254
255         // Timers
256         int setTimeout(PassOwnPtr<ScheduledAction>, int timeout, ExceptionCode&);
257         void clearTimeout(int timeoutId);
258         int setInterval(PassOwnPtr<ScheduledAction>, int timeout, ExceptionCode&);
259         void clearInterval(int timeoutId);
260
261         // WebKit animation extensions
262 #if ENABLE(REQUEST_ANIMATION_FRAME)
263         int requestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback>);
264         int webkitRequestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback>);
265         void cancelAnimationFrame(int id);
266 #endif
267
268 #if ENABLE(CSS3_CONDITIONAL_RULES)
269         DOMWindowCSS* css();
270 #endif
271
272         // Events
273         // EventTarget API
274         virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture) override;
275         virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture) override;
276         virtual void removeAllEventListeners() override;
277
278         using EventTarget::dispatchEvent;
279         bool dispatchEvent(PassRefPtr<Event> prpEvent, PassRefPtr<EventTarget> prpTarget);
280
281         void dispatchLoadEvent();
282
283         DEFINE_ATTRIBUTE_EVENT_LISTENER(abort);
284         DEFINE_ATTRIBUTE_EVENT_LISTENER(beforeunload);
285         DEFINE_ATTRIBUTE_EVENT_LISTENER(blur);
286         DEFINE_ATTRIBUTE_EVENT_LISTENER(canplay);
287         DEFINE_ATTRIBUTE_EVENT_LISTENER(canplaythrough);
288         DEFINE_ATTRIBUTE_EVENT_LISTENER(change);
289         DEFINE_ATTRIBUTE_EVENT_LISTENER(click);
290         DEFINE_ATTRIBUTE_EVENT_LISTENER(contextmenu);
291         DEFINE_ATTRIBUTE_EVENT_LISTENER(dblclick);
292         DEFINE_ATTRIBUTE_EVENT_LISTENER(drag);
293         DEFINE_ATTRIBUTE_EVENT_LISTENER(dragend);
294         DEFINE_ATTRIBUTE_EVENT_LISTENER(dragenter);
295         DEFINE_ATTRIBUTE_EVENT_LISTENER(dragleave);
296         DEFINE_ATTRIBUTE_EVENT_LISTENER(dragover);
297         DEFINE_ATTRIBUTE_EVENT_LISTENER(dragstart);
298         DEFINE_ATTRIBUTE_EVENT_LISTENER(drop);
299         DEFINE_ATTRIBUTE_EVENT_LISTENER(durationchange);
300         DEFINE_ATTRIBUTE_EVENT_LISTENER(emptied);
301         DEFINE_ATTRIBUTE_EVENT_LISTENER(ended);
302         DEFINE_ATTRIBUTE_EVENT_LISTENER(error);
303         DEFINE_ATTRIBUTE_EVENT_LISTENER(focus);
304         DEFINE_ATTRIBUTE_EVENT_LISTENER(hashchange);
305         DEFINE_ATTRIBUTE_EVENT_LISTENER(input);
306         DEFINE_ATTRIBUTE_EVENT_LISTENER(invalid);
307         DEFINE_ATTRIBUTE_EVENT_LISTENER(keydown);
308         DEFINE_ATTRIBUTE_EVENT_LISTENER(keypress);
309         DEFINE_ATTRIBUTE_EVENT_LISTENER(keyup);
310         DEFINE_ATTRIBUTE_EVENT_LISTENER(load);
311         DEFINE_ATTRIBUTE_EVENT_LISTENER(loadeddata);
312         DEFINE_ATTRIBUTE_EVENT_LISTENER(loadedmetadata);
313         DEFINE_ATTRIBUTE_EVENT_LISTENER(loadstart);
314         DEFINE_ATTRIBUTE_EVENT_LISTENER(message);
315         DEFINE_ATTRIBUTE_EVENT_LISTENER(mousedown);
316         DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseenter);
317         DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseleave);
318         DEFINE_ATTRIBUTE_EVENT_LISTENER(mousemove);
319         DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseout);
320         DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseover);
321         DEFINE_ATTRIBUTE_EVENT_LISTENER(mouseup);
322         DEFINE_ATTRIBUTE_EVENT_LISTENER(mousewheel);
323         DEFINE_ATTRIBUTE_EVENT_LISTENER(offline);
324         DEFINE_ATTRIBUTE_EVENT_LISTENER(online);
325         DEFINE_ATTRIBUTE_EVENT_LISTENER(pagehide);
326         DEFINE_ATTRIBUTE_EVENT_LISTENER(pageshow);
327         DEFINE_ATTRIBUTE_EVENT_LISTENER(pause);
328         DEFINE_ATTRIBUTE_EVENT_LISTENER(play);
329         DEFINE_ATTRIBUTE_EVENT_LISTENER(playing);
330         DEFINE_ATTRIBUTE_EVENT_LISTENER(popstate);
331         DEFINE_ATTRIBUTE_EVENT_LISTENER(progress);
332         DEFINE_ATTRIBUTE_EVENT_LISTENER(ratechange);
333         DEFINE_ATTRIBUTE_EVENT_LISTENER(reset);
334         DEFINE_ATTRIBUTE_EVENT_LISTENER(resize);
335         DEFINE_ATTRIBUTE_EVENT_LISTENER(scroll);
336         DEFINE_ATTRIBUTE_EVENT_LISTENER(search);
337         DEFINE_ATTRIBUTE_EVENT_LISTENER(seeked);
338         DEFINE_ATTRIBUTE_EVENT_LISTENER(seeking);
339         DEFINE_ATTRIBUTE_EVENT_LISTENER(select);
340         DEFINE_ATTRIBUTE_EVENT_LISTENER(stalled);
341         DEFINE_ATTRIBUTE_EVENT_LISTENER(storage);
342         DEFINE_ATTRIBUTE_EVENT_LISTENER(submit);
343         DEFINE_ATTRIBUTE_EVENT_LISTENER(suspend);
344         DEFINE_ATTRIBUTE_EVENT_LISTENER(timeupdate);
345         DEFINE_ATTRIBUTE_EVENT_LISTENER(unload);
346         DEFINE_ATTRIBUTE_EVENT_LISTENER(volumechange);
347         DEFINE_ATTRIBUTE_EVENT_LISTENER(waiting);
348         DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitbeginfullscreen);
349         DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitendfullscreen);
350 #if ENABLE(WILL_REVEAL_EDGE_EVENTS)
351         DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitwillrevealbottom);
352         DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitwillrevealleft);
353         DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitwillrevealright);
354         DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitwillrevealtop);
355 #endif
356         DEFINE_ATTRIBUTE_EVENT_LISTENER(wheel);
357
358         DEFINE_MAPPED_ATTRIBUTE_EVENT_LISTENER(webkitanimationstart, webkitAnimationStart);
359         DEFINE_MAPPED_ATTRIBUTE_EVENT_LISTENER(webkitanimationiteration, webkitAnimationIteration);
360         DEFINE_MAPPED_ATTRIBUTE_EVENT_LISTENER(webkitanimationend, webkitAnimationEnd);
361         DEFINE_MAPPED_ATTRIBUTE_EVENT_LISTENER(webkittransitionend, webkitTransitionEnd);
362         DEFINE_MAPPED_ATTRIBUTE_EVENT_LISTENER(transitionend, transitionend);
363
364         void captureEvents();
365         void releaseEvents();
366
367         void finishedLoading();
368
369         using RefCounted<DOMWindow>::ref;
370         using RefCounted<DOMWindow>::deref;
371
372 #if ENABLE(DEVICE_ORIENTATION)
373         DEFINE_ATTRIBUTE_EVENT_LISTENER(devicemotion);
374         DEFINE_ATTRIBUTE_EVENT_LISTENER(deviceorientation);
375 #endif
376
377 #if ENABLE(PROXIMITY_EVENTS)
378         DEFINE_ATTRIBUTE_EVENT_LISTENER(webkitdeviceproximity);
379 #endif
380
381         // HTML 5 key/value storage
382         Storage* sessionStorage(ExceptionCode&) const;
383         Storage* localStorage(ExceptionCode&) const;
384         Storage* optionalSessionStorage() const { return m_sessionStorage.get(); }
385         Storage* optionalLocalStorage() const { return m_localStorage.get(); }
386
387         DOMApplicationCache* applicationCache() const;
388         DOMApplicationCache* optionalApplicationCache() const { return m_applicationCache.get(); }
389
390 #if ENABLE(ORIENTATION_EVENTS)
391         // This is the interface orientation in degrees. Some examples are:
392         //  0 is straight up; -90 is when the device is rotated 90 clockwise;
393         //  90 is when rotated counter clockwise.
394         int orientation() const;
395
396         DEFINE_ATTRIBUTE_EVENT_LISTENER(orientationchange);
397 #endif
398
399 #if ENABLE(TOUCH_EVENTS)
400         DEFINE_ATTRIBUTE_EVENT_LISTENER(touchstart);
401         DEFINE_ATTRIBUTE_EVENT_LISTENER(touchmove);
402         DEFINE_ATTRIBUTE_EVENT_LISTENER(touchend);
403         DEFINE_ATTRIBUTE_EVENT_LISTENER(touchcancel);
404 #endif
405
406 #if ENABLE(IOS_GESTURE_EVENTS)
407         DEFINE_ATTRIBUTE_EVENT_LISTENER(gesturestart);
408         DEFINE_ATTRIBUTE_EVENT_LISTENER(gesturechange);
409         DEFINE_ATTRIBUTE_EVENT_LISTENER(gestureend);
410 #endif
411
412 #if ENABLE(WEB_TIMING)
413         Performance* performance() const;
414 #endif
415
416 #if PLATFORM(IOS)
417         void incrementScrollEventListenersCount();
418         void decrementScrollEventListenersCount();
419         unsigned scrollEventListenerCount() const { return m_scrollEventListenerCount; }
420 #endif
421
422         void resetAllGeolocationPermission();
423
424 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
425         bool hasTouchEventListeners() const { return m_touchEventListenerCount > 0; }
426 #endif
427
428         // FIXME: When this DOMWindow is no longer the active DOMWindow (i.e.,
429         // when its document is no longer the document that is displayed in its
430         // frame), we would like to zero out m_frame to avoid being confused
431         // by the document that is currently active in m_frame.
432         bool isCurrentlyDisplayedInFrame() const;
433
434         void willDetachDocumentFromFrame();
435         void willDestroyCachedFrame();
436
437         void enableSuddenTermination();
438         void disableSuddenTermination();
439
440     private:
441         explicit DOMWindow(Document*);
442
443         Page* page();
444         bool allowedToChangeWindowGeometry() const;
445
446         virtual void frameDestroyed() override;
447         virtual void willDetachPage() override;
448
449         virtual void refEventTarget() override { ref(); }
450         virtual void derefEventTarget() override { deref(); }
451
452         static PassRefPtr<Frame> createWindow(const String& urlString, const AtomicString& frameName, const WindowFeatures&, DOMWindow& activeWindow, Frame* firstFrame, Frame* openerFrame, std::function<void (DOMWindow&)> prepareDialogFunction = nullptr);
453         bool isInsecureScriptAccess(DOMWindow& activeWindow, const String& urlString);
454
455         void resetDOMWindowProperties();
456         void disconnectDOMWindowProperties();
457         void reconnectDOMWindowProperties();
458         void willDestroyDocumentInFrame();
459
460         bool m_shouldPrintWhenFinishedLoading;
461         bool m_suspendedForPageCache;
462
463         HashSet<DOMWindowProperty*> m_properties;
464
465         mutable RefPtr<Screen> m_screen;
466         mutable RefPtr<History> m_history;
467         mutable RefPtr<Crypto>  m_crypto;
468         mutable RefPtr<BarProp> m_locationbar;
469         mutable RefPtr<BarProp> m_menubar;
470         mutable RefPtr<BarProp> m_personalbar;
471         mutable RefPtr<BarProp> m_scrollbars;
472         mutable RefPtr<BarProp> m_statusbar;
473         mutable RefPtr<BarProp> m_toolbar;
474         mutable RefPtr<Navigator> m_navigator;
475         mutable RefPtr<Location> m_location;
476         mutable RefPtr<StyleMedia> m_media;
477
478         String m_status;
479         String m_defaultStatus;
480
481         enum PageStatus { PageStatusNone, PageStatusShown, PageStatusHidden };
482         PageStatus m_lastPageStatus;
483
484 #if PLATFORM(IOS)
485         unsigned m_scrollEventListenerCount;
486 #endif
487
488 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
489         unsigned m_touchEventListenerCount;
490 #endif
491
492         mutable RefPtr<Storage> m_sessionStorage;
493         mutable RefPtr<Storage> m_localStorage;
494         mutable RefPtr<DOMApplicationCache> m_applicationCache;
495
496 #if ENABLE(WEB_TIMING)
497         mutable RefPtr<Performance> m_performance;
498 #endif
499
500 #if ENABLE(CSS3_CONDITIONAL_RULES)
501         mutable RefPtr<DOMWindowCSS> m_css;
502 #endif
503     };
504
505     inline String DOMWindow::status() const
506     {
507         return m_status;
508     }
509
510     inline String DOMWindow::defaultStatus() const
511     {
512         return m_defaultStatus;
513     }
514
515 } // namespace WebCore
516
517 #endif // DOMWindow_h