b48224ebf2d6860c43c959a51b6e5c48c3fc3814
[WebKit-https.git] / Source / WebCore / page / DOMWindow.h
1 /*
2  * Copyright (C) 2006-2017 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 #pragma once
28
29 #include "AbstractDOMWindow.h"
30 #include "Base64Utilities.h"
31 #include "ContextDestructionObserver.h"
32 #include "ExceptionOr.h"
33 #include "Frame.h"
34 #include "FrameDestructionObserver.h"
35 #include "ImageBitmap.h"
36 #include "ScrollToOptions.h"
37 #include "ScrollTypes.h"
38 #include "Supplementable.h"
39 #include <JavaScriptCore/HandleTypes.h>
40 #include <wtf/Function.h>
41 #include <wtf/HashSet.h>
42 #include <wtf/WeakPtr.h>
43
44 namespace JSC {
45 class CallFrame;
46 class JSObject;
47 class JSValue;
48 template<typename> class Strong;
49 using ExecState = CallFrame;
50 }
51
52 namespace WebCore {
53
54 class BarProp;
55 class CSSRuleList;
56 class CSSStyleDeclaration;
57 class Crypto;
58 class CustomElementRegistry;
59 class DOMApplicationCache;
60 class DOMSelection;
61 class DOMWindowProperty;
62 class DOMWrapperWorld;
63 class Document;
64 class Element;
65 class EventListener;
66 class FloatRect;
67 class History;
68 class Location;
69 class MediaQueryList;
70 class Navigator;
71 class Node;
72 class NodeList;
73 class Page;
74 class PageConsoleClient;
75 class Performance;
76 class PostMessageTimer;
77 class RequestAnimationFrameCallback;
78 class ScheduledAction;
79 class Screen;
80 class Storage;
81 class StyleMedia;
82 class VisualViewport;
83 class WebKitNamespace;
84 class WebKitPoint;
85
86 #if ENABLE(DEVICE_ORIENTATION)
87 class DeviceMotionController;
88 class DeviceOrientationController;
89 #endif
90
91 struct ImageBitmapOptions;
92 struct WindowFeatures;
93
94 enum SetLocationLocking { LockHistoryBasedOnGestureState, LockHistoryAndBackForwardList };
95 enum class IncludeTargetOrigin { No, Yes };
96
97 // FIXME: Rename DOMWindow to LocalWindow and AbstractDOMWindow to DOMWindow.
98 class DOMWindow final
99     : public AbstractDOMWindow
100     , public CanMakeWeakPtr<DOMWindow>
101     , public ContextDestructionObserver
102     , public Base64Utilities
103     , public Supplementable<DOMWindow> {
104     WTF_MAKE_ISO_ALLOCATED(DOMWindow);
105 public:
106
107     static Ref<DOMWindow> create(Document& document) { return adoptRef(*new DOMWindow(document)); }
108     WEBCORE_EXPORT virtual ~DOMWindow();
109
110     // In some rare cases, we'll reuse a DOMWindow for a new Document. For example,
111     // when a script calls window.open("..."), the browser gives JavaScript a window
112     // synchronously but kicks off the load in the window asynchronously. Web sites
113     // expect that modifications that they make to the window object synchronously
114     // won't be blown away when the network load commits. To make that happen, we
115     // "securely transition" the existing DOMWindow to the Document that results from
116     // the network load. See also SecurityContext::isSecureTransitionTo.
117     void didSecureTransitionTo(Document&);
118
119     class Observer {
120     public:
121         virtual ~Observer() { }
122
123         virtual void suspendForPageCache() { }
124         virtual void resumeFromPageCache() { }
125         virtual void willDestroyGlobalObjectInCachedFrame() { }
126         virtual void willDestroyGlobalObjectInFrame() { }
127         virtual void willDetachGlobalObjectFromFrame() { }
128     };
129
130     void registerObserver(Observer&);
131     void unregisterObserver(Observer&);
132
133     void resetUnlessSuspendedForDocumentSuspension();
134     void suspendForPageCache();
135     void resumeFromPageCache();
136
137     WEBCORE_EXPORT Frame* frame() const final;
138
139     RefPtr<MediaQueryList> matchMedia(const String&);
140
141     WEBCORE_EXPORT unsigned pendingUnloadEventListeners() const;
142
143     WEBCORE_EXPORT static bool dispatchAllPendingBeforeUnloadEvents();
144     WEBCORE_EXPORT static void dispatchAllPendingUnloadEvents();
145
146     static FloatRect adjustWindowRect(Page&, const FloatRect& pendingChanges);
147
148     bool allowPopUp(); // Call on first window, not target window.
149     static bool allowPopUp(Frame& firstFrame);
150     static bool canShowModalDialog(const Frame&);
151     WEBCORE_EXPORT void setCanShowModalDialogOverride(bool);
152
153     Screen& screen();
154     History& history();
155     Crypto& crypto() const;
156     BarProp& locationbar();
157     BarProp& menubar();
158     BarProp& personalbar();
159     BarProp& scrollbars();
160     BarProp& statusbar();
161     BarProp& toolbar();
162     WEBCORE_EXPORT Navigator& navigator();
163     Navigator* optionalNavigator() const { return m_navigator.get(); }
164     Navigator& clientInformation() { return navigator(); }
165
166     Location& location();
167     void setLocation(DOMWindow& activeWindow, const URL& completedURL, SetLocationLocking = LockHistoryBasedOnGestureState);
168
169     DOMSelection* getSelection();
170
171     Element* frameElement() const;
172
173     WEBCORE_EXPORT void focus(bool allowFocus = false);
174     void focus(DOMWindow& incumbentWindow);
175     void blur();
176     WEBCORE_EXPORT void close();
177     void close(Document&);
178     void print();
179     void stop();
180
181     WEBCORE_EXPORT ExceptionOr<RefPtr<WindowProxy>> open(DOMWindow& activeWindow, DOMWindow& firstWindow, const String& urlString, const AtomString& frameName, const String& windowFeaturesString);
182
183     void showModalDialog(const String& urlString, const String& dialogFeaturesString, DOMWindow& activeWindow, DOMWindow& firstWindow, const WTF::Function<void(DOMWindow&)>& prepareDialogFunction);
184
185     void prewarmLocalStorageIfNecessary();
186
187     void alert(const String& message = emptyString());
188     bool confirmForBindings(const String& message);
189     String prompt(const String& message, const String& defaultValue);
190
191     bool find(const String&, bool caseSensitive, bool backwards, bool wrap, bool wholeWord, bool searchInFrames, bool showDialog) const;
192
193     bool offscreenBuffering() const;
194
195     int outerHeight() const;
196     int outerWidth() const;
197     int innerHeight() const;
198     int innerWidth() const;
199     int screenX() const;
200     int screenY() const;
201     int screenLeft() const { return screenX(); }
202     int screenTop() const { return screenY(); }
203     int scrollX() const;
204     int scrollY() const;
205
206     bool closed() const;
207
208     unsigned length() const;
209
210     String name() const;
211     void setName(const String&);
212
213     String status() const;
214     void setStatus(const String&);
215     String defaultStatus() const;
216     void setDefaultStatus(const String&);
217
218     WindowProxy* opener() const;
219     void disownOpener();
220     WindowProxy* parent() const;
221     WindowProxy* top() const;
222
223     String origin() const;
224
225     // DOM Level 2 AbstractView Interface
226
227     WEBCORE_EXPORT Document* document() const;
228
229     // CSSOM View Module
230
231     StyleMedia& styleMedia();
232
233     // DOM Level 2 Style Interface
234
235     WEBCORE_EXPORT Ref<CSSStyleDeclaration> getComputedStyle(Element&, const String& pseudoElt) const;
236
237     // WebKit extensions
238
239     WEBCORE_EXPORT RefPtr<CSSRuleList> getMatchedCSSRules(Element*, const String& pseudoElt, bool authorOnly = true) const;
240     double devicePixelRatio() const;
241
242     RefPtr<WebKitPoint> webkitConvertPointFromPageToNode(Node*, const WebKitPoint*) const;
243     RefPtr<WebKitPoint> webkitConvertPointFromNodeToPage(Node*, const WebKitPoint*) const;
244
245     PageConsoleClient* console() const;
246
247     void printErrorMessage(const String&);
248
249     String crossDomainAccessErrorMessage(const DOMWindow& activeWindow, IncludeTargetOrigin);
250
251     ExceptionOr<void> postMessage(JSC::ExecState&, DOMWindow& incumbentWindow, JSC::JSValue message, const String& targetOrigin, Vector<JSC::Strong<JSC::JSObject>>&&);
252     void postMessageTimerFired(PostMessageTimer&);
253
254     void languagesChanged();
255
256     void scrollBy(const ScrollToOptions&) const;
257     void scrollBy(double x, double y) const;
258     void scrollTo(const ScrollToOptions&, ScrollClamping = ScrollClamping::Clamped) const;
259     void scrollTo(double x, double y, ScrollClamping = ScrollClamping::Clamped) const;
260
261     void moveBy(float x, float y) const;
262     void moveTo(float x, float y) const;
263
264     void resizeBy(float x, float y) const;
265     void resizeTo(float width, float height) const;
266
267     VisualViewport& visualViewport();
268
269     // Timers
270     ExceptionOr<int> setTimeout(JSC::ExecState&, std::unique_ptr<ScheduledAction>, int timeout, Vector<JSC::Strong<JSC::Unknown>>&& arguments);
271     void clearTimeout(int timeoutId);
272     ExceptionOr<int> setInterval(JSC::ExecState&, std::unique_ptr<ScheduledAction>, int timeout, Vector<JSC::Strong<JSC::Unknown>>&& arguments);
273     void clearInterval(int timeoutId);
274
275     int requestAnimationFrame(Ref<RequestAnimationFrameCallback>&&);
276     int webkitRequestAnimationFrame(Ref<RequestAnimationFrameCallback>&&);
277     void cancelAnimationFrame(int id);
278
279     // ImageBitmap
280     void createImageBitmap(ImageBitmap::Source&&, ImageBitmapOptions&&, ImageBitmap::Promise&&);
281     void createImageBitmap(ImageBitmap::Source&&, int sx, int sy, int sw, int sh, ImageBitmapOptions&&, ImageBitmap::Promise&&);
282
283     // Secure Contexts
284     bool isSecureContext() const;
285
286     // Events
287     // EventTarget API
288     bool addEventListener(const AtomString& eventType, Ref<EventListener>&&, const AddEventListenerOptions&) final;
289     bool removeEventListener(const AtomString& eventType, EventListener&, const ListenerOptions&) final;
290     void removeAllEventListeners() final;
291
292     using EventTarget::dispatchEvent;
293     void dispatchEvent(Event&, EventTarget*);
294
295     void dispatchLoadEvent();
296
297     void captureEvents();
298     void releaseEvents();
299
300     void finishedLoading();
301
302     // HTML 5 key/value storage
303     ExceptionOr<Storage*> sessionStorage();
304     ExceptionOr<Storage*> localStorage();
305     Storage* optionalSessionStorage() const { return m_sessionStorage.get(); }
306     Storage* optionalLocalStorage() const { return m_localStorage.get(); }
307
308     DOMApplicationCache& applicationCache();
309     DOMApplicationCache* optionalApplicationCache() const { return m_applicationCache.get(); }
310
311     CustomElementRegistry* customElementRegistry() { return m_customElementRegistry.get(); }
312     CustomElementRegistry& ensureCustomElementRegistry();
313
314     ExceptionOr<Ref<NodeList>> collectMatchingElementsInFlatTree(Node&, const String& selectors);
315     ExceptionOr<RefPtr<Element>> matchingElementInFlatTree(Node&, const String& selectors);
316
317 #if ENABLE(ORIENTATION_EVENTS)
318     // This is the interface orientation in degrees. Some examples are:
319     //  0 is straight up; -90 is when the device is rotated 90 clockwise;
320     //  90 is when rotated counter clockwise.
321     int orientation() const;
322 #endif
323
324     Performance& performance() const;
325     WEBCORE_EXPORT double nowTimestamp() const;
326
327 #if PLATFORM(IOS_FAMILY)
328     void incrementScrollEventListenersCount();
329     void decrementScrollEventListenersCount();
330     unsigned scrollEventListenerCount() const { return m_scrollEventListenerCount; }
331 #endif
332
333 #if ENABLE(DEVICE_ORIENTATION)
334     void startListeningForDeviceOrientationIfNecessary();
335     void stopListeningForDeviceOrientationIfNecessary();
336     void startListeningForDeviceMotionIfNecessary();
337     void stopListeningForDeviceMotionIfNecessary();
338
339     bool isAllowedToUseDeviceMotionOrientation(String& message) const;
340     bool isAllowedToAddDeviceMotionOrientationListener(String& message) const;
341
342     DeviceOrientationController* deviceOrientationController() const;
343     DeviceMotionController* deviceMotionController() const;
344 #endif
345
346     void resetAllGeolocationPermission();
347
348 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
349     bool hasTouchOrGestureEventListeners() const { return m_touchAndGestureEventListenerCount > 0; }
350 #endif
351
352 #if ENABLE(USER_MESSAGE_HANDLERS)
353     bool shouldHaveWebKitNamespaceForWorld(DOMWrapperWorld&);
354     WebKitNamespace* webkitNamespace();
355 #endif
356
357     // FIXME: When this DOMWindow is no longer the active DOMWindow (i.e.,
358     // when its document is no longer the document that is displayed in its
359     // frame), we would like to zero out m_frame to avoid being confused
360     // by the document that is currently active in m_frame.
361     bool isCurrentlyDisplayedInFrame() const;
362
363     void willDetachDocumentFromFrame();
364     void willDestroyCachedFrame();
365
366     void enableSuddenTermination();
367     void disableSuddenTermination();
368
369     void willDestroyDocumentInFrame();
370     void frameDestroyed();
371
372 private:
373     explicit DOMWindow(Document&);
374
375     ScriptExecutionContext* scriptExecutionContext() const final { return ContextDestructionObserver::scriptExecutionContext(); }
376
377     bool isLocalDOMWindow() const final { return true; }
378     bool isRemoteDOMWindow() const final { return false; }
379
380     Page* page();
381     bool allowedToChangeWindowGeometry() const;
382
383     static ExceptionOr<RefPtr<Frame>> createWindow(const String& urlString, const AtomString& frameName, const WindowFeatures&, DOMWindow& activeWindow, Frame& firstFrame, Frame& openerFrame, const WTF::Function<void(DOMWindow&)>& prepareDialogFunction = nullptr);
384     bool isInsecureScriptAccess(DOMWindow& activeWindow, const String& urlString);
385
386 #if ENABLE(DEVICE_ORIENTATION)
387     void failedToRegisterDeviceMotionEventListener();
388 #endif
389
390     bool isSameSecurityOriginAsMainFrame() const;
391
392 #if ENABLE(GAMEPAD)
393     void incrementGamepadEventListenerCount();
394     void decrementGamepadEventListenerCount();
395 #endif
396
397     bool m_shouldPrintWhenFinishedLoading { false };
398     bool m_suspendedForDocumentSuspension { false };
399     bool m_isSuspendingObservers { false };
400     Optional<bool> m_canShowModalDialogOverride;
401
402     HashSet<Observer*> m_observers;
403
404     mutable RefPtr<Crypto> m_crypto;
405     mutable RefPtr<History> m_history;
406     mutable RefPtr<BarProp> m_locationbar;
407     mutable RefPtr<StyleMedia> m_media;
408     mutable RefPtr<BarProp> m_menubar;
409     mutable RefPtr<Navigator> m_navigator;
410     mutable RefPtr<BarProp> m_personalbar;
411     mutable RefPtr<Screen> m_screen;
412     mutable RefPtr<BarProp> m_scrollbars;
413     mutable RefPtr<DOMSelection> m_selection;
414     mutable RefPtr<BarProp> m_statusbar;
415     mutable RefPtr<BarProp> m_toolbar;
416     mutable RefPtr<Location> m_location;
417     mutable RefPtr<VisualViewport> m_visualViewport;
418
419     String m_status;
420     String m_defaultStatus;
421
422     enum class PageStatus { None, Shown, Hidden };
423     PageStatus m_lastPageStatus { PageStatus::None };
424
425 #if PLATFORM(IOS_FAMILY)
426     unsigned m_scrollEventListenerCount { 0 };
427 #endif
428
429 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
430     unsigned m_touchAndGestureEventListenerCount { 0 };
431 #endif
432
433 #if ENABLE(GAMEPAD)
434     unsigned m_gamepadEventListenerCount { 0 };
435 #endif
436
437     mutable RefPtr<Storage> m_sessionStorage;
438     mutable RefPtr<Storage> m_localStorage;
439     mutable RefPtr<DOMApplicationCache> m_applicationCache;
440
441     RefPtr<CustomElementRegistry> m_customElementRegistry;
442
443     mutable RefPtr<Performance> m_performance;
444
445 #if ENABLE(USER_MESSAGE_HANDLERS)
446     mutable RefPtr<WebKitNamespace> m_webkitNamespace;
447 #endif
448 };
449
450 inline String DOMWindow::status() const
451 {
452     return m_status;
453 }
454
455 inline String DOMWindow::defaultStatus() const
456 {
457     return m_defaultStatus;
458 }
459
460 } // namespace WebCore
461
462 SPECIALIZE_TYPE_TRAITS_BEGIN(WebCore::DOMWindow)
463     static bool isType(const WebCore::AbstractDOMWindow& window) { return window.isLocalDOMWindow(); }
464     static bool isType(const WebCore::EventTarget& target) { return target.eventTargetInterface() == WebCore::DOMWindowEventTargetInterfaceType; }
465 SPECIALIZE_TYPE_TRAITS_END()