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