Block popups from content extensions.
[WebKit-https.git] / Source / WebCore / page / DOMWindow.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2010, 2013 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 #include "config.h"
28 #include "DOMWindow.h"
29
30 #include "BackForwardController.h"
31 #include "BarProp.h"
32 #include "BeforeUnloadEvent.h"
33 #include "CSSComputedStyleDeclaration.h"
34 #include "CSSRule.h"
35 #include "CSSRuleList.h"
36 #include "Chrome.h"
37 #include "ChromeClient.h"
38 #include "ContentExtensionActions.h"
39 #include "ContentExtensionRule.h"
40 #include "Crypto.h"
41 #include "DOMApplicationCache.h"
42 #include "DOMSelection.h"
43 #include "DOMSettableTokenList.h"
44 #include "DOMStringList.h"
45 #include "DOMTimer.h"
46 #include "DOMTokenList.h"
47 #include "DOMURL.h"
48 #include "DOMWindowCSS.h"
49 #include "DOMWindowExtension.h"
50 #include "DOMWindowNotifications.h"
51 #include "DeviceMotionController.h"
52 #include "DeviceOrientationController.h"
53 #include "Document.h"
54 #include "DocumentLoader.h"
55 #include "Editor.h"
56 #include "Element.h"
57 #include "EventException.h"
58 #include "EventHandler.h"
59 #include "EventListener.h"
60 #include "EventNames.h"
61 #include "ExceptionCode.h"
62 #include "ExceptionCodePlaceholder.h"
63 #include "FloatRect.h"
64 #include "FocusController.h"
65 #include "FrameLoadRequest.h"
66 #include "FrameLoader.h"
67 #include "FrameLoaderClient.h"
68 #include "FrameTree.h"
69 #include "FrameView.h"
70 #include "HTMLFrameOwnerElement.h"
71 #include "History.h"
72 #include "InspectorInstrumentation.h"
73 #include "JSMainThreadExecState.h"
74 #include "Location.h"
75 #include "MainFrame.h"
76 #include "MediaQueryList.h"
77 #include "MediaQueryMatcher.h"
78 #include "MessageEvent.h"
79 #include "Navigator.h"
80 #include "Page.h"
81 #include "PageConsoleClient.h"
82 #include "PageGroup.h"
83 #include "PageTransitionEvent.h"
84 #include "Performance.h"
85 #include "PlatformScreen.h"
86 #include "ResourceLoadInfo.h"
87 #include "RuntimeEnabledFeatures.h"
88 #include "ScheduledAction.h"
89 #include "Screen.h"
90 #include "ScriptController.h"
91 #include "SecurityOrigin.h"
92 #include "SecurityPolicy.h"
93 #include "SerializedScriptValue.h"
94 #include "Settings.h"
95 #include "Storage.h"
96 #include "StorageArea.h"
97 #include "StorageNamespace.h"
98 #include "StorageNamespaceProvider.h"
99 #include "StyleMedia.h"
100 #include "StyleResolver.h"
101 #include "SuddenTermination.h"
102 #include "URL.h"
103 #include "WebKitPoint.h"
104 #include "WindowFeatures.h"
105 #include "WindowFocusAllowedIndicator.h"
106 #include <JavaScriptCore/Profile.h>
107 #include <algorithm>
108 #include <inspector/ScriptCallStack.h>
109 #include <inspector/ScriptCallStackFactory.h>
110 #include <memory>
111 #include <wtf/CurrentTime.h>
112 #include <wtf/MainThread.h>
113 #include <wtf/MathExtras.h>
114 #include <wtf/Ref.h>
115 #include <wtf/text/Base64.h>
116 #include <wtf/text/WTFString.h>
117
118 #if ENABLE(USER_MESSAGE_HANDLERS)
119 #include "UserContentController.h"
120 #include "UserMessageHandlerDescriptor.h"
121 #include "WebKitNamespace.h"
122 #endif
123
124 #if ENABLE(PROXIMITY_EVENTS)
125 #include "DeviceProximityController.h"
126 #endif
127
128 #if ENABLE(REQUEST_ANIMATION_FRAME)
129 #include "RequestAnimationFrameCallback.h"
130 #endif
131
132 #if ENABLE(GAMEPAD)
133 #include "GamepadManager.h"
134 #endif
135
136 #if PLATFORM(IOS)
137 #if ENABLE(GEOLOCATION)
138 #include "NavigatorGeolocation.h"
139 #endif
140 #include "WKContentObservation.h"
141 #endif
142
143 using namespace Inspector;
144
145 namespace WebCore {
146
147 class PostMessageTimer : public TimerBase {
148 public:
149     PostMessageTimer(DOMWindow* window, PassRefPtr<SerializedScriptValue> message, const String& sourceOrigin, PassRefPtr<DOMWindow> source, std::unique_ptr<MessagePortChannelArray> channels, SecurityOrigin* targetOrigin, PassRefPtr<ScriptCallStack> stackTrace)
150         : m_window(window)
151         , m_message(message)
152         , m_origin(sourceOrigin)
153         , m_source(source)
154         , m_channels(WTF::move(channels))
155         , m_targetOrigin(targetOrigin)
156         , m_stackTrace(stackTrace)
157     {
158     }
159
160     PassRefPtr<MessageEvent> event(ScriptExecutionContext* context)
161     {
162         std::unique_ptr<MessagePortArray> messagePorts = MessagePort::entanglePorts(*context, WTF::move(m_channels));
163         return MessageEvent::create(WTF::move(messagePorts), m_message, m_origin, String(), m_source);
164     }
165     SecurityOrigin* targetOrigin() const { return m_targetOrigin.get(); }
166     ScriptCallStack* stackTrace() const { return m_stackTrace.get(); }
167
168 private:
169     virtual void fired()
170     {
171         // This object gets deleted when std::unique_ptr falls out of scope..
172         std::unique_ptr<PostMessageTimer> timer(this);
173         m_window->postMessageTimerFired(*timer);
174     }
175
176     RefPtr<DOMWindow> m_window;
177     RefPtr<SerializedScriptValue> m_message;
178     String m_origin;
179     RefPtr<DOMWindow> m_source;
180     std::unique_ptr<MessagePortChannelArray> m_channels;
181     RefPtr<SecurityOrigin> m_targetOrigin;
182     RefPtr<ScriptCallStack> m_stackTrace;
183 };
184
185 typedef HashCountedSet<DOMWindow*> DOMWindowSet;
186
187 static DOMWindowSet& windowsWithUnloadEventListeners()
188 {
189     DEPRECATED_DEFINE_STATIC_LOCAL(DOMWindowSet, windowsWithUnloadEventListeners, ());
190     return windowsWithUnloadEventListeners;
191 }
192
193 static DOMWindowSet& windowsWithBeforeUnloadEventListeners()
194 {
195     DEPRECATED_DEFINE_STATIC_LOCAL(DOMWindowSet, windowsWithBeforeUnloadEventListeners, ());
196     return windowsWithBeforeUnloadEventListeners;
197 }
198
199 static void addUnloadEventListener(DOMWindow* domWindow)
200 {
201     if (windowsWithUnloadEventListeners().add(domWindow).isNewEntry)
202         domWindow->disableSuddenTermination();
203 }
204
205 static void removeUnloadEventListener(DOMWindow* domWindow)
206 {
207     if (windowsWithUnloadEventListeners().remove(domWindow))
208         domWindow->enableSuddenTermination();
209 }
210
211 static void removeAllUnloadEventListeners(DOMWindow* domWindow)
212 {
213     if (windowsWithUnloadEventListeners().removeAll(domWindow))
214         domWindow->enableSuddenTermination();
215 }
216
217 static void addBeforeUnloadEventListener(DOMWindow* domWindow)
218 {
219     if (windowsWithBeforeUnloadEventListeners().add(domWindow).isNewEntry)
220         domWindow->disableSuddenTermination();
221 }
222
223 static void removeBeforeUnloadEventListener(DOMWindow* domWindow)
224 {
225     if (windowsWithBeforeUnloadEventListeners().remove(domWindow))
226         domWindow->enableSuddenTermination();
227 }
228
229 static void removeAllBeforeUnloadEventListeners(DOMWindow* domWindow)
230 {
231     if (windowsWithBeforeUnloadEventListeners().removeAll(domWindow))
232         domWindow->enableSuddenTermination();
233 }
234
235 static bool allowsBeforeUnloadListeners(DOMWindow* window)
236 {
237     ASSERT_ARG(window, window);
238     Frame* frame = window->frame();
239     if (!frame)
240         return false;
241     if (!frame->page())
242         return false;
243     return frame->isMainFrame();
244 }
245
246 bool DOMWindow::dispatchAllPendingBeforeUnloadEvents()
247 {
248     DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();
249     if (set.isEmpty())
250         return true;
251
252     static bool alreadyDispatched = false;
253     ASSERT(!alreadyDispatched);
254     if (alreadyDispatched)
255         return true;
256
257     Vector<Ref<DOMWindow>> windows;
258     windows.reserveInitialCapacity(set.size());
259     for (auto it = set.begin(), end = set.end(); it != end; ++it)
260         windows.uncheckedAppend(*it->key);
261
262     for (Ref<DOMWindow>& windowRef : windows) {
263         DOMWindow& window = windowRef;
264         if (!set.contains(&window))
265             continue;
266
267         Frame* frame = window.frame();
268         if (!frame)
269             continue;
270
271         if (!frame->loader().shouldClose())
272             return false;
273
274         window.enableSuddenTermination();
275     }
276
277     alreadyDispatched = true;
278     return true;
279 }
280
281 unsigned DOMWindow::pendingUnloadEventListeners() const
282 {
283     return windowsWithUnloadEventListeners().count(const_cast<DOMWindow*>(this));
284 }
285
286 void DOMWindow::dispatchAllPendingUnloadEvents()
287 {
288     DOMWindowSet& set = windowsWithUnloadEventListeners();
289     if (set.isEmpty())
290         return;
291
292     static bool alreadyDispatched = false;
293     ASSERT(!alreadyDispatched);
294     if (alreadyDispatched)
295         return;
296
297     Vector<Ref<DOMWindow>> windows;
298     windows.reserveInitialCapacity(set.size());
299     for (auto& keyValue : set)
300         windows.uncheckedAppend(*keyValue.key);
301
302     for (Ref<DOMWindow>& windowRef : windows) {
303         DOMWindow& window = windowRef;
304         if (!set.contains(&window))
305             continue;
306
307         window.dispatchEvent(PageTransitionEvent::create(eventNames().pagehideEvent, false), window.document());
308         window.dispatchEvent(Event::create(eventNames().unloadEvent, false, false), window.document());
309
310         window.enableSuddenTermination();
311     }
312
313     alreadyDispatched = true;
314 }
315
316 // This function:
317 // 1) Validates the pending changes are not changing any value to NaN; in that case keep original value.
318 // 2) Constrains the window rect to the minimum window size and no bigger than the float rect's dimensions.
319 // 3) Constrains the window rect to within the top and left boundaries of the available screen rect.
320 // 4) Constrains the window rect to within the bottom and right boundaries of the available screen rect.
321 // 5) Translate the window rect coordinates to be within the coordinate space of the screen.
322 FloatRect DOMWindow::adjustWindowRect(Page* page, const FloatRect& pendingChanges)
323 {
324     ASSERT(page);
325
326     FloatRect screen = screenAvailableRect(page->mainFrame().view());
327     FloatRect window = page->chrome().windowRect();
328
329     // Make sure we're in a valid state before adjusting dimensions.
330     ASSERT(std::isfinite(screen.x()));
331     ASSERT(std::isfinite(screen.y()));
332     ASSERT(std::isfinite(screen.width()));
333     ASSERT(std::isfinite(screen.height()));
334     ASSERT(std::isfinite(window.x()));
335     ASSERT(std::isfinite(window.y()));
336     ASSERT(std::isfinite(window.width()));
337     ASSERT(std::isfinite(window.height()));
338
339     // Update window values if new requested values are not NaN.
340     if (!std::isnan(pendingChanges.x()))
341         window.setX(pendingChanges.x());
342     if (!std::isnan(pendingChanges.y()))
343         window.setY(pendingChanges.y());
344     if (!std::isnan(pendingChanges.width()))
345         window.setWidth(pendingChanges.width());
346     if (!std::isnan(pendingChanges.height()))
347         window.setHeight(pendingChanges.height());
348
349     FloatSize minimumSize = page->chrome().client().minimumWindowSize();
350     window.setWidth(std::min(std::max(minimumSize.width(), window.width()), screen.width()));
351     window.setHeight(std::min(std::max(minimumSize.height(), window.height()), screen.height()));
352
353     // Constrain the window position within the valid screen area.
354     window.setX(std::max(screen.x(), std::min(window.x(), screen.maxX() - window.width())));
355     window.setY(std::max(screen.y(), std::min(window.y(), screen.maxY() - window.height())));
356
357     return window;
358 }
359
360 bool DOMWindow::allowPopUp(Frame* firstFrame)
361 {
362     ASSERT(firstFrame);
363
364     if (ScriptController::processingUserGesture())
365         return true;
366
367     return firstFrame->settings().javaScriptCanOpenWindowsAutomatically();
368 }
369
370 bool DOMWindow::allowPopUp()
371 {
372     return m_frame && allowPopUp(m_frame);
373 }
374
375 bool DOMWindow::canShowModalDialog(const Frame* frame)
376 {
377     if (!frame)
378         return false;
379     Page* page = frame->page();
380     if (!page)
381         return false;
382     return page->chrome().canRunModal();
383 }
384
385 bool DOMWindow::canShowModalDialogNow(const Frame* frame)
386 {
387     if (!frame)
388         return false;
389     Page* page = frame->page();
390     if (!page)
391         return false;
392     return page->chrome().canRunModalNow();
393 }
394
395 DOMWindow::DOMWindow(Document* document)
396     : ContextDestructionObserver(document)
397     , FrameDestructionObserver(document->frame())
398     , m_shouldPrintWhenFinishedLoading(false)
399     , m_suspendedForPageCache(false)
400     , m_lastPageStatus(PageStatusNone)
401     , m_weakPtrFactory(this)
402 #if PLATFORM(IOS)
403     , m_scrollEventListenerCount(0)
404 #endif
405 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
406     , m_touchEventListenerCount(0)
407 #endif
408 #if ENABLE(GAMEPAD)
409     , m_gamepadEventListenerCount(0)
410 #endif
411 {
412     ASSERT(frame());
413     ASSERT(DOMWindow::document());
414 }
415
416 void DOMWindow::didSecureTransitionTo(Document* document)
417 {
418     observeContext(document);
419 }
420
421 DOMWindow::~DOMWindow()
422 {
423 #ifndef NDEBUG
424     if (!m_suspendedForPageCache) {
425         ASSERT(!m_screen);
426         ASSERT(!m_history);
427         ASSERT(!m_crypto);
428         ASSERT(!m_locationbar);
429         ASSERT(!m_menubar);
430         ASSERT(!m_personalbar);
431         ASSERT(!m_scrollbars);
432         ASSERT(!m_statusbar);
433         ASSERT(!m_toolbar);
434         ASSERT(!m_navigator);
435 #if ENABLE(WEB_TIMING)
436         ASSERT(!m_performance);
437 #endif
438         ASSERT(!m_location);
439         ASSERT(!m_media);
440         ASSERT(!m_sessionStorage);
441         ASSERT(!m_localStorage);
442         ASSERT(!m_applicationCache);
443     }
444 #endif
445
446     if (m_suspendedForPageCache)
447         willDestroyCachedFrame();
448     else
449         willDestroyDocumentInFrame();
450
451     // As the ASSERTs above indicate, this reset should only be necessary if this DOMWindow is suspended for the page cache.
452     // But we don't want to risk any of these objects hanging around after we've been destroyed.
453     resetDOMWindowProperties();
454
455     removeAllUnloadEventListeners(this);
456     removeAllBeforeUnloadEventListeners(this);
457
458 #if ENABLE(GAMEPAD)
459     if (m_gamepadEventListenerCount)
460         GamepadManager::singleton().unregisterDOMWindow(this);
461 #endif
462 }
463
464 DOMWindow* DOMWindow::toDOMWindow()
465 {
466     return this;
467 }
468
469 PassRefPtr<MediaQueryList> DOMWindow::matchMedia(const String& media)
470 {
471     return document() ? document()->mediaQueryMatcher().matchMedia(media) : 0;
472 }
473
474 Page* DOMWindow::page()
475 {
476     return frame() ? frame()->page() : 0;
477 }
478
479 void DOMWindow::frameDestroyed()
480 {
481     willDestroyDocumentInFrame();
482     FrameDestructionObserver::frameDestroyed();
483     resetDOMWindowProperties();
484     JSDOMWindowBase::fireFrameClearedWatchpointsForWindow(this);
485 }
486
487 void DOMWindow::willDetachPage()
488 {
489     InspectorInstrumentation::frameWindowDiscarded(m_frame, this);
490 }
491
492 void DOMWindow::willDestroyCachedFrame()
493 {
494     // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
495     // unregister themselves from the DOMWindow as a result of the call to willDestroyGlobalObjectInCachedFrame.
496     Vector<DOMWindowProperty*> properties;
497     copyToVector(m_properties, properties);
498     for (size_t i = 0; i < properties.size(); ++i)
499         properties[i]->willDestroyGlobalObjectInCachedFrame();
500 }
501
502 void DOMWindow::willDestroyDocumentInFrame()
503 {
504     // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
505     // unregister themselves from the DOMWindow as a result of the call to willDestroyGlobalObjectInFrame.
506     Vector<DOMWindowProperty*> properties;
507     copyToVector(m_properties, properties);
508     for (size_t i = 0; i < properties.size(); ++i)
509         properties[i]->willDestroyGlobalObjectInFrame();
510 }
511
512 void DOMWindow::willDetachDocumentFromFrame()
513 {
514     // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
515     // unregister themselves from the DOMWindow as a result of the call to willDetachGlobalObjectFromFrame.
516     Vector<DOMWindowProperty*> properties;
517     copyToVector(m_properties, properties);
518     for (size_t i = 0; i < properties.size(); ++i)
519         properties[i]->willDetachGlobalObjectFromFrame();
520 }
521
522 #if ENABLE(GAMEPAD)
523 void DOMWindow::incrementGamepadEventListenerCount()
524 {
525     if (++m_gamepadEventListenerCount == 1)
526         GamepadManager::singleton().registerDOMWindow(this);
527 }
528
529 void DOMWindow::decrementGamepadEventListenerCount()
530 {
531     ASSERT(m_gamepadEventListenerCount);
532
533     if (!--m_gamepadEventListenerCount)
534         GamepadManager::singleton().unregisterDOMWindow(this);
535 }
536 #endif
537
538 void DOMWindow::registerProperty(DOMWindowProperty* property)
539 {
540     m_properties.add(property);
541 }
542
543 void DOMWindow::unregisterProperty(DOMWindowProperty* property)
544 {
545     m_properties.remove(property);
546 }
547
548 void DOMWindow::resetUnlessSuspendedForPageCache()
549 {
550     if (m_suspendedForPageCache)
551         return;
552     willDestroyDocumentInFrame();
553     resetDOMWindowProperties();
554 }
555
556 void DOMWindow::suspendForPageCache()
557 {
558     disconnectDOMWindowProperties();
559     m_suspendedForPageCache = true;
560 }
561
562 void DOMWindow::resumeFromPageCache()
563 {
564     reconnectDOMWindowProperties();
565     m_suspendedForPageCache = false;
566 }
567
568 void DOMWindow::disconnectDOMWindowProperties()
569 {
570     // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
571     // unregister themselves from the DOMWindow as a result of the call to disconnectFrameForPageCache.
572     Vector<DOMWindowProperty*> properties;
573     copyToVector(m_properties, properties);
574     for (size_t i = 0; i < properties.size(); ++i)
575         properties[i]->disconnectFrameForPageCache();
576 }
577
578 void DOMWindow::reconnectDOMWindowProperties()
579 {
580     ASSERT(m_suspendedForPageCache);
581     // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
582     // unregister themselves from the DOMWindow as a result of the call to reconnectFromPageCache.
583     Vector<DOMWindowProperty*> properties;
584     copyToVector(m_properties, properties);
585     for (size_t i = 0; i < properties.size(); ++i)
586         properties[i]->reconnectFrameFromPageCache(m_frame);
587 }
588
589 void DOMWindow::resetDOMWindowProperties()
590 {
591     m_properties.clear();
592
593     m_screen = 0;
594     m_history = 0;
595     m_crypto = 0;
596     m_locationbar = 0;
597     m_menubar = 0;
598     m_personalbar = 0;
599     m_scrollbars = 0;
600     m_statusbar = 0;
601     m_toolbar = 0;
602     m_navigator = 0;
603 #if ENABLE(WEB_TIMING)
604     m_performance = 0;
605 #endif
606     m_location = 0;
607     m_media = 0;
608     m_sessionStorage = 0;
609     m_localStorage = 0;
610     m_applicationCache = 0;
611 }
612
613 bool DOMWindow::isCurrentlyDisplayedInFrame() const
614 {
615     return m_frame && m_frame->document()->domWindow() == this;
616 }
617
618 #if ENABLE(ORIENTATION_EVENTS)
619 int DOMWindow::orientation() const
620 {
621     if (!m_frame)
622         return 0;
623
624     return m_frame->orientation();
625 }
626 #endif
627
628 Screen* DOMWindow::screen() const
629 {
630     if (!isCurrentlyDisplayedInFrame())
631         return 0;
632     if (!m_screen)
633         m_screen = Screen::create(m_frame);
634     return m_screen.get();
635 }
636
637 History* DOMWindow::history() const
638 {
639     if (!isCurrentlyDisplayedInFrame())
640         return 0;
641     if (!m_history)
642         m_history = History::create(m_frame);
643     return m_history.get();
644 }
645
646 Crypto* DOMWindow::crypto() const
647 {
648     // FIXME: Why is crypto not available when the window is not currently displayed in a frame?
649     if (!isCurrentlyDisplayedInFrame())
650         return 0;
651     if (!m_crypto)
652         m_crypto = Crypto::create(*document());
653     return m_crypto.get();
654 }
655
656 BarProp* DOMWindow::locationbar() const
657 {
658     if (!isCurrentlyDisplayedInFrame())
659         return 0;
660     if (!m_locationbar)
661         m_locationbar = BarProp::create(m_frame, BarProp::Locationbar);
662     return m_locationbar.get();
663 }
664
665 BarProp* DOMWindow::menubar() const
666 {
667     if (!isCurrentlyDisplayedInFrame())
668         return 0;
669     if (!m_menubar)
670         m_menubar = BarProp::create(m_frame, BarProp::Menubar);
671     return m_menubar.get();
672 }
673
674 BarProp* DOMWindow::personalbar() const
675 {
676     if (!isCurrentlyDisplayedInFrame())
677         return 0;
678     if (!m_personalbar)
679         m_personalbar = BarProp::create(m_frame, BarProp::Personalbar);
680     return m_personalbar.get();
681 }
682
683 BarProp* DOMWindow::scrollbars() const
684 {
685     if (!isCurrentlyDisplayedInFrame())
686         return 0;
687     if (!m_scrollbars)
688         m_scrollbars = BarProp::create(m_frame, BarProp::Scrollbars);
689     return m_scrollbars.get();
690 }
691
692 BarProp* DOMWindow::statusbar() const
693 {
694     if (!isCurrentlyDisplayedInFrame())
695         return 0;
696     if (!m_statusbar)
697         m_statusbar = BarProp::create(m_frame, BarProp::Statusbar);
698     return m_statusbar.get();
699 }
700
701 BarProp* DOMWindow::toolbar() const
702 {
703     if (!isCurrentlyDisplayedInFrame())
704         return 0;
705     if (!m_toolbar)
706         m_toolbar = BarProp::create(m_frame, BarProp::Toolbar);
707     return m_toolbar.get();
708 }
709
710 PageConsoleClient* DOMWindow::console() const
711 {
712     if (!isCurrentlyDisplayedInFrame())
713         return nullptr;
714     return m_frame->page() ? &m_frame->page()->console() : nullptr;
715 }
716
717 DOMApplicationCache* DOMWindow::applicationCache() const
718 {
719     if (!isCurrentlyDisplayedInFrame())
720         return 0;
721     if (!m_applicationCache)
722         m_applicationCache = DOMApplicationCache::create(m_frame);
723     return m_applicationCache.get();
724 }
725
726 Navigator* DOMWindow::navigator() const
727 {
728     if (!isCurrentlyDisplayedInFrame())
729         return 0;
730     if (!m_navigator)
731         m_navigator = Navigator::create(m_frame);
732     return m_navigator.get();
733 }
734
735 #if ENABLE(WEB_TIMING)
736 Performance* DOMWindow::performance() const
737 {
738     if (!isCurrentlyDisplayedInFrame())
739         return 0;
740     if (!m_performance)
741         m_performance = Performance::create(m_frame);
742     return m_performance.get();
743 }
744 #endif
745
746 Location* DOMWindow::location() const
747 {
748     if (!isCurrentlyDisplayedInFrame())
749         return 0;
750     if (!m_location)
751         m_location = Location::create(m_frame);
752     return m_location.get();
753 }
754
755 #if ENABLE(USER_MESSAGE_HANDLERS)
756 bool DOMWindow::shouldHaveWebKitNamespaceForWorld(DOMWrapperWorld& world)
757 {
758     if (!m_frame)
759         return false;
760
761     auto* page = m_frame->page();
762     if (!page)
763         return false;
764
765     auto* userContentController = page->userContentController();
766     if (!userContentController)
767         return false;
768
769     auto* descriptorMap = userContentController->userMessageHandlerDescriptors();
770     if (!descriptorMap)
771         return false;
772
773     for (auto& descriptor : descriptorMap->values()) {
774         if (&descriptor->world() == &world)
775             return true;
776     }
777
778     return false;
779 }
780
781 WebKitNamespace* DOMWindow::webkitNamespace() const
782 {
783     if (!isCurrentlyDisplayedInFrame())
784         return nullptr;
785     if (!m_webkitNamespace)
786         m_webkitNamespace = WebKitNamespace::create(*m_frame);
787     return m_webkitNamespace.get();
788 }
789 #endif
790
791 Storage* DOMWindow::sessionStorage(ExceptionCode& ec) const
792 {
793     if (!isCurrentlyDisplayedInFrame())
794         return 0;
795
796     Document* document = this->document();
797     if (!document)
798         return 0;
799
800     if (!document->securityOrigin()->canAccessSessionStorage(document->topOrigin())) {
801         ec = SECURITY_ERR;
802         return 0;
803     }
804
805     if (m_sessionStorage) {
806         if (!m_sessionStorage->area().canAccessStorage(m_frame)) {
807             ec = SECURITY_ERR;
808             return 0;
809         }
810         return m_sessionStorage.get();
811     }
812
813     Page* page = document->page();
814     if (!page)
815         return 0;
816
817     RefPtr<StorageArea> storageArea = page->sessionStorage()->storageArea(document->securityOrigin());
818     if (!storageArea->canAccessStorage(m_frame)) {
819         ec = SECURITY_ERR;
820         return 0;
821     }
822
823     m_sessionStorage = Storage::create(m_frame, storageArea.release());
824     return m_sessionStorage.get();
825 }
826
827 Storage* DOMWindow::localStorage(ExceptionCode& ec) const
828 {
829     if (!isCurrentlyDisplayedInFrame())
830         return nullptr;
831
832     Document* document = this->document();
833     if (!document)
834         return nullptr;
835
836     if (!document->securityOrigin()->canAccessLocalStorage(0)) {
837         ec = SECURITY_ERR;
838         return nullptr;
839     }
840
841     Page* page = document->page();
842     // FIXME: We should consider supporting access/modification to local storage
843     // after calling window.close(). See <https://bugs.webkit.org/show_bug.cgi?id=135330>.
844     if (!page || !page->isClosing()) {
845         if (m_localStorage) {
846             if (!m_localStorage->area().canAccessStorage(m_frame)) {
847                 ec = SECURITY_ERR;
848                 return nullptr;
849             }
850             return m_localStorage.get();
851         }
852     }
853
854     if (!page)
855         return nullptr;
856
857     if (page->isClosing())
858         return nullptr;
859
860     if (!page->settings().localStorageEnabled())
861         return nullptr;
862
863     RefPtr<StorageArea> storageArea = page->storageNamespaceProvider().localStorageArea(*document);
864
865     if (!storageArea->canAccessStorage(m_frame)) {
866         ec = SECURITY_ERR;
867         return nullptr;
868     }
869
870     m_localStorage = Storage::create(m_frame, storageArea.release());
871     return m_localStorage.get();
872 }
873
874 void DOMWindow::postMessage(PassRefPtr<SerializedScriptValue> message, MessagePort* port, const String& targetOrigin, DOMWindow& source, ExceptionCode& ec)
875 {
876     MessagePortArray ports;
877     if (port)
878         ports.append(port);
879     postMessage(message, &ports, targetOrigin, source, ec);
880 }
881
882 void DOMWindow::postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, const String& targetOrigin, DOMWindow& source, ExceptionCode& ec)
883 {
884     if (!isCurrentlyDisplayedInFrame())
885         return;
886
887     Document* sourceDocument = source.document();
888
889     // Compute the target origin.  We need to do this synchronously in order
890     // to generate the SYNTAX_ERR exception correctly.
891     RefPtr<SecurityOrigin> target;
892     if (targetOrigin == "/") {
893         if (!sourceDocument)
894             return;
895         target = sourceDocument->securityOrigin();
896     } else if (targetOrigin != "*") {
897         target = SecurityOrigin::createFromString(targetOrigin);
898         // It doesn't make sense target a postMessage at a unique origin
899         // because there's no way to represent a unique origin in a string.
900         if (target->isUnique()) {
901             ec = SYNTAX_ERR;
902             return;
903         }
904     }
905
906     std::unique_ptr<MessagePortChannelArray> channels = MessagePort::disentanglePorts(ports, ec);
907     if (ec)
908         return;
909
910     // Capture the source of the message.  We need to do this synchronously
911     // in order to capture the source of the message correctly.
912     if (!sourceDocument)
913         return;
914     String sourceOrigin = sourceDocument->securityOrigin()->toString();
915
916     // Capture stack trace only when inspector front-end is loaded as it may be time consuming.
917     RefPtr<ScriptCallStack> stackTrace;
918     if (InspectorInstrumentation::consoleAgentEnabled(sourceDocument))
919         stackTrace = createScriptCallStack(JSMainThreadExecState::currentState(), ScriptCallStack::maxCallStackSizeToCapture);
920
921     // Schedule the message.
922     PostMessageTimer* timer = new PostMessageTimer(this, message, sourceOrigin, &source, WTF::move(channels), target.get(), stackTrace.release());
923     timer->startOneShot(0);
924 }
925
926 void DOMWindow::postMessageTimerFired(PostMessageTimer& timer)
927 {
928     if (!document() || !isCurrentlyDisplayedInFrame())
929         return;
930
931     dispatchMessageEventWithOriginCheck(timer.targetOrigin(), timer.event(document()), timer.stackTrace());
932 }
933
934 void DOMWindow::dispatchMessageEventWithOriginCheck(SecurityOrigin* intendedTargetOrigin, PassRefPtr<Event> event, PassRefPtr<ScriptCallStack> stackTrace)
935 {
936     if (intendedTargetOrigin) {
937         // Check target origin now since the target document may have changed since the timer was scheduled.
938         if (!intendedTargetOrigin->isSameSchemeHostPort(document()->securityOrigin())) {
939             String message = "Unable to post message to " + intendedTargetOrigin->toString() +
940                              ". Recipient has origin " + document()->securityOrigin()->toString() + ".\n";
941             console()->addMessage(MessageSource::Security, MessageLevel::Error, message, stackTrace);
942             return;
943         }
944     }
945
946     dispatchEvent(event);
947 }
948
949 DOMSelection* DOMWindow::getSelection()
950 {
951     if (!isCurrentlyDisplayedInFrame() || !m_frame)
952         return 0;
953
954     return m_frame->document()->getSelection();
955 }
956
957 Element* DOMWindow::frameElement() const
958 {
959     if (!m_frame)
960         return 0;
961
962     return m_frame->ownerElement();
963 }
964
965 void DOMWindow::focus(ScriptExecutionContext* context)
966 {
967     if (!m_frame)
968         return;
969
970     Page* page = m_frame->page();
971     if (!page)
972         return;
973
974     bool allowFocus = WindowFocusAllowedIndicator::windowFocusAllowed() || !m_frame->settings().windowFocusRestricted();
975     if (context) {
976         ASSERT(isMainThread());
977         Document& activeDocument = downcast<Document>(*context);
978         if (opener() && opener() != this && activeDocument.domWindow() == opener())
979             allowFocus = true;
980     }
981
982     // If we're a top level window, bring the window to the front.
983     if (m_frame->isMainFrame() && allowFocus)
984         page->chrome().focus();
985
986     if (!m_frame)
987         return;
988
989     // Clear the current frame's focused node if a new frame is about to be focused.
990     Frame* focusedFrame = page->focusController().focusedFrame();
991     if (focusedFrame && focusedFrame != m_frame)
992         focusedFrame->document()->setFocusedElement(0);
993
994     m_frame->eventHandler().focusDocumentView();
995 }
996
997 void DOMWindow::blur()
998 {
999     if (!m_frame)
1000         return;
1001
1002     Page* page = m_frame->page();
1003     if (!page)
1004         return;
1005
1006     if (m_frame->settings().windowFocusRestricted())
1007         return;
1008
1009     if (!m_frame->isMainFrame())
1010         return;
1011
1012     page->chrome().unfocus();
1013 }
1014
1015 void DOMWindow::close(ScriptExecutionContext* context)
1016 {
1017     if (!m_frame)
1018         return;
1019
1020     Page* page = m_frame->page();
1021     if (!page)
1022         return;
1023
1024     if (!m_frame->isMainFrame())
1025         return;
1026
1027     if (context) {
1028         ASSERT(isMainThread());
1029         if (!downcast<Document>(*context).canNavigate(m_frame))
1030             return;
1031     }
1032
1033     bool allowScriptsToCloseWindows = m_frame->settings().allowScriptsToCloseWindows();
1034
1035     if (!(page->openedByDOM() || page->backForward().count() <= 1 || allowScriptsToCloseWindows)) {
1036         console()->addMessage(MessageSource::JS, MessageLevel::Warning, ASCIILiteral("Can't close the window since it was not opened by JavaScript"));
1037         return;
1038     }
1039
1040     if (!m_frame->loader().shouldClose())
1041         return;
1042
1043     page->setIsClosing();
1044     page->chrome().closeWindowSoon();
1045 }
1046
1047 void DOMWindow::print()
1048 {
1049     if (!m_frame)
1050         return;
1051
1052     Page* page = m_frame->page();
1053     if (!page)
1054         return;
1055
1056     // Pages are not allowed to bring up a modal print dialog during BeforeUnload dispatch.
1057     if (page->isAnyFrameHandlingBeforeUnloadEvent()) {
1058         printErrorMessage("Use of window.print is not allowed during beforeunload event dispatch.");
1059         return;
1060     }
1061
1062     if (m_frame->loader().activeDocumentLoader()->isLoading()) {
1063         m_shouldPrintWhenFinishedLoading = true;
1064         return;
1065     }
1066     m_shouldPrintWhenFinishedLoading = false;
1067     page->chrome().print(m_frame);
1068 }
1069
1070 void DOMWindow::stop()
1071 {
1072     if (!m_frame)
1073         return;
1074
1075     // We must check whether the load is complete asynchronously, because we might still be parsing
1076     // the document until the callstack unwinds.
1077     m_frame->loader().stopForUserCancel(true);
1078 }
1079
1080 void DOMWindow::alert(const String& message)
1081 {
1082     if (!m_frame)
1083         return;
1084
1085     // Pages are not allowed to cause modal alerts during BeforeUnload dispatch.
1086     if (page() && page()->isAnyFrameHandlingBeforeUnloadEvent()) {
1087         printErrorMessage("Use of window.alert is not allowed during beforeunload event dispatch.");
1088         return;
1089     }
1090
1091     m_frame->document()->updateStyleIfNeeded();
1092
1093     Page* page = m_frame->page();
1094     if (!page)
1095         return;
1096
1097     page->chrome().runJavaScriptAlert(m_frame, message);
1098 }
1099
1100 bool DOMWindow::confirm(const String& message)
1101 {
1102     if (!m_frame)
1103         return false;
1104     
1105     // Pages are not allowed to cause modal alerts during BeforeUnload dispatch.
1106     if (page() && page()->isAnyFrameHandlingBeforeUnloadEvent()) {
1107         printErrorMessage("Use of window.confirm is not allowed during beforeunload event dispatch.");
1108         return false;
1109     }
1110
1111     m_frame->document()->updateStyleIfNeeded();
1112
1113     Page* page = m_frame->page();
1114     if (!page)
1115         return false;
1116
1117     return page->chrome().runJavaScriptConfirm(m_frame, message);
1118 }
1119
1120 String DOMWindow::prompt(const String& message, const String& defaultValue)
1121 {
1122     if (!m_frame)
1123         return String();
1124
1125     // Pages are not allowed to cause modal alerts during BeforeUnload dispatch.
1126     if (page() && page()->isAnyFrameHandlingBeforeUnloadEvent()) {
1127         printErrorMessage("Use of window.prompt is not allowed during beforeunload event dispatch.");
1128         return String();
1129     }
1130
1131     m_frame->document()->updateStyleIfNeeded();
1132
1133     Page* page = m_frame->page();
1134     if (!page)
1135         return String();
1136
1137     String returnValue;
1138     if (page->chrome().runJavaScriptPrompt(m_frame, message, defaultValue, returnValue))
1139         return returnValue;
1140
1141     return String();
1142 }
1143
1144 String DOMWindow::btoa(const String& stringToEncode, ExceptionCode& ec)
1145 {
1146     if (stringToEncode.isNull())
1147         return String();
1148
1149     if (!stringToEncode.containsOnlyLatin1()) {
1150         ec = INVALID_CHARACTER_ERR;
1151         return String();
1152     }
1153
1154     return base64Encode(stringToEncode.latin1());
1155 }
1156
1157 String DOMWindow::atob(const String& encodedString, ExceptionCode& ec)
1158 {
1159     if (encodedString.isNull())
1160         return String();
1161
1162     if (!encodedString.containsOnlyLatin1()) {
1163         ec = INVALID_CHARACTER_ERR;
1164         return String();
1165     }
1166
1167     Vector<char> out;
1168     if (!base64Decode(encodedString, out, Base64FailOnInvalidCharacterOrExcessPadding)) {
1169         ec = INVALID_CHARACTER_ERR;
1170         return String();
1171     }
1172
1173     return String(out.data(), out.size());
1174 }
1175
1176 bool DOMWindow::find(const String& string, bool caseSensitive, bool backwards, bool wrap, bool /*wholeWord*/, bool /*searchInFrames*/, bool /*showDialog*/) const
1177 {
1178     if (!isCurrentlyDisplayedInFrame())
1179         return false;
1180
1181     // FIXME (13016): Support wholeWord, searchInFrames and showDialog.    
1182     FindOptions options = (backwards ? Backwards : 0) | (caseSensitive ? 0 : CaseInsensitive) | (wrap ? WrapAround : 0);
1183     return m_frame->editor().findString(string, options);
1184 }
1185
1186 bool DOMWindow::offscreenBuffering() const
1187 {
1188     return true;
1189 }
1190
1191 int DOMWindow::outerHeight() const
1192 {
1193 #if PLATFORM(IOS)
1194     return 0;
1195 #else
1196     if (!m_frame)
1197         return 0;
1198
1199     Page* page = m_frame->page();
1200     if (!page)
1201         return 0;
1202
1203     return static_cast<int>(page->chrome().windowRect().height());
1204 #endif
1205 }
1206
1207 int DOMWindow::outerWidth() const
1208 {
1209 #if PLATFORM(IOS)
1210     return 0;
1211 #else
1212     if (!m_frame)
1213         return 0;
1214
1215     Page* page = m_frame->page();
1216     if (!page)
1217         return 0;
1218
1219     return static_cast<int>(page->chrome().windowRect().width());
1220 #endif
1221 }
1222
1223 int DOMWindow::innerHeight() const
1224 {
1225     if (!m_frame)
1226         return 0;
1227
1228     FrameView* view = m_frame->view();
1229     if (!view)
1230         return 0;
1231
1232     return view->mapFromLayoutToCSSUnits(static_cast<int>(view->unobscuredContentRectIncludingScrollbars().height()));
1233 }
1234
1235 int DOMWindow::innerWidth() const
1236 {
1237     if (!m_frame)
1238         return 0;
1239
1240     FrameView* view = m_frame->view();
1241     if (!view)
1242         return 0;
1243
1244     return view->mapFromLayoutToCSSUnits(static_cast<int>(view->unobscuredContentRectIncludingScrollbars().width()));
1245 }
1246
1247 int DOMWindow::screenX() const
1248 {
1249     if (!m_frame)
1250         return 0;
1251
1252     Page* page = m_frame->page();
1253     if (!page)
1254         return 0;
1255
1256     return static_cast<int>(page->chrome().windowRect().x());
1257 }
1258
1259 int DOMWindow::screenY() const
1260 {
1261     if (!m_frame)
1262         return 0;
1263
1264     Page* page = m_frame->page();
1265     if (!page)
1266         return 0;
1267
1268     return static_cast<int>(page->chrome().windowRect().y());
1269 }
1270
1271 int DOMWindow::scrollX() const
1272 {
1273     if (!m_frame)
1274         return 0;
1275
1276     FrameView* view = m_frame->view();
1277     if (!view)
1278         return 0;
1279
1280     int scrollX = view->contentsScrollPosition().x();
1281     if (!scrollX)
1282         return 0;
1283
1284     m_frame->document()->updateLayoutIgnorePendingStylesheets();
1285
1286     return view->mapFromLayoutToCSSUnits(view->contentsScrollPosition().x());
1287 }
1288
1289 int DOMWindow::scrollY() const
1290 {
1291     if (!m_frame)
1292         return 0;
1293
1294     FrameView* view = m_frame->view();
1295     if (!view)
1296         return 0;
1297
1298     int scrollY = view->contentsScrollPosition().y();
1299     if (!scrollY)
1300         return 0;
1301
1302     m_frame->document()->updateLayoutIgnorePendingStylesheets();
1303
1304     return view->mapFromLayoutToCSSUnits(view->contentsScrollPosition().y());
1305 }
1306
1307 bool DOMWindow::closed() const
1308 {
1309     return !m_frame;
1310 }
1311
1312 unsigned DOMWindow::length() const
1313 {
1314     if (!isCurrentlyDisplayedInFrame())
1315         return 0;
1316
1317     return m_frame->tree().scopedChildCount();
1318 }
1319
1320 String DOMWindow::name() const
1321 {
1322     if (!m_frame)
1323         return String();
1324
1325     return m_frame->tree().name();
1326 }
1327
1328 void DOMWindow::setName(const String& string)
1329 {
1330     if (!m_frame)
1331         return;
1332
1333     m_frame->tree().setName(string);
1334 }
1335
1336 void DOMWindow::setStatus(const String& string) 
1337 {
1338     m_status = string;
1339
1340     if (!m_frame)
1341         return;
1342
1343     Page* page = m_frame->page();
1344     if (!page)
1345         return;
1346
1347     ASSERT(m_frame->document()); // Client calls shouldn't be made when the frame is in inconsistent state.
1348     page->chrome().setStatusbarText(m_frame, m_status);
1349
1350     
1351 void DOMWindow::setDefaultStatus(const String& string) 
1352 {
1353     m_defaultStatus = string;
1354
1355     if (!m_frame)
1356         return;
1357
1358     Page* page = m_frame->page();
1359     if (!page)
1360         return;
1361
1362     ASSERT(m_frame->document()); // Client calls shouldn't be made when the frame is in inconsistent state.
1363     page->chrome().setStatusbarText(m_frame, m_defaultStatus);
1364 }
1365
1366 DOMWindow* DOMWindow::self() const
1367 {
1368     if (!m_frame)
1369         return 0;
1370
1371     return m_frame->document()->domWindow();
1372 }
1373
1374 DOMWindow* DOMWindow::opener() const
1375 {
1376     if (!m_frame)
1377         return 0;
1378
1379     Frame* opener = m_frame->loader().opener();
1380     if (!opener)
1381         return 0;
1382
1383     return opener->document()->domWindow();
1384 }
1385
1386 DOMWindow* DOMWindow::parent() const
1387 {
1388     if (!m_frame)
1389         return 0;
1390
1391     Frame* parent = m_frame->tree().parent();
1392     if (parent)
1393         return parent->document()->domWindow();
1394
1395     return m_frame->document()->domWindow();
1396 }
1397
1398 DOMWindow* DOMWindow::top() const
1399 {
1400     if (!m_frame)
1401         return 0;
1402
1403     Page* page = m_frame->page();
1404     if (!page)
1405         return 0;
1406
1407     return m_frame->tree().top().document()->domWindow();
1408 }
1409
1410 Document* DOMWindow::document() const
1411 {
1412     ScriptExecutionContext* context = ContextDestructionObserver::scriptExecutionContext();
1413     return downcast<Document>(context);
1414 }
1415
1416 PassRefPtr<StyleMedia> DOMWindow::styleMedia() const
1417 {
1418     if (!isCurrentlyDisplayedInFrame())
1419         return nullptr;
1420     if (!m_media)
1421         m_media = StyleMedia::create(m_frame);
1422     return m_media.get();
1423 }
1424
1425 PassRefPtr<CSSStyleDeclaration> DOMWindow::getComputedStyle(Element* element, const String& pseudoElt) const
1426 {
1427     if (!element)
1428         return nullptr;
1429
1430     return CSSComputedStyleDeclaration::create(element, false, pseudoElt);
1431 }
1432
1433 PassRefPtr<CSSRuleList> DOMWindow::getMatchedCSSRules(Element* element, const String& pseudoElement, bool authorOnly) const
1434 {
1435     if (!isCurrentlyDisplayedInFrame())
1436         return 0;
1437
1438     unsigned colonStart = pseudoElement[0] == ':' ? (pseudoElement[1] == ':' ? 2 : 1) : 0;
1439     CSSSelector::PseudoElementType pseudoType = CSSSelector::parsePseudoElementType(pseudoElement.substringSharingImpl(colonStart));
1440     if (pseudoType == CSSSelector::PseudoElementUnknown && !pseudoElement.isEmpty())
1441         return 0;
1442
1443     unsigned rulesToInclude = StyleResolver::AuthorCSSRules;
1444     if (!authorOnly)
1445         rulesToInclude |= StyleResolver::UAAndUserCSSRules;
1446     if (m_frame->settings().crossOriginCheckInGetMatchedCSSRulesDisabled())
1447         rulesToInclude |= StyleResolver::CrossOriginCSSRules;
1448
1449     PseudoId pseudoId = CSSSelector::pseudoId(pseudoType);
1450
1451     auto matchedRules = m_frame->document()->ensureStyleResolver().pseudoStyleRulesForElement(element, pseudoId, rulesToInclude);
1452     if (matchedRules.isEmpty())
1453         return 0;
1454
1455     RefPtr<StaticCSSRuleList> ruleList = StaticCSSRuleList::create();
1456     for (unsigned i = 0; i < matchedRules.size(); ++i)
1457         ruleList->rules().append(matchedRules[i]->createCSSOMWrapper());
1458
1459     return ruleList.release();
1460 }
1461
1462 PassRefPtr<WebKitPoint> DOMWindow::webkitConvertPointFromNodeToPage(Node* node, const WebKitPoint* p) const
1463 {
1464     if (!node || !p)
1465         return 0;
1466
1467     if (!document())
1468         return 0;
1469
1470     document()->updateLayoutIgnorePendingStylesheets();
1471
1472     FloatPoint pagePoint(p->x(), p->y());
1473     pagePoint = node->convertToPage(pagePoint);
1474     return WebKitPoint::create(pagePoint.x(), pagePoint.y());
1475 }
1476
1477 PassRefPtr<WebKitPoint> DOMWindow::webkitConvertPointFromPageToNode(Node* node, const WebKitPoint* p) const
1478 {
1479     if (!node || !p)
1480         return 0;
1481
1482     if (!document())
1483         return 0;
1484
1485     document()->updateLayoutIgnorePendingStylesheets();
1486
1487     FloatPoint nodePoint(p->x(), p->y());
1488     nodePoint = node->convertFromPage(nodePoint);
1489     return WebKitPoint::create(nodePoint.x(), nodePoint.y());
1490 }
1491
1492 double DOMWindow::devicePixelRatio() const
1493 {
1494     if (!m_frame)
1495         return 0.0;
1496
1497     Page* page = m_frame->page();
1498     if (!page)
1499         return 0.0;
1500
1501     return page->deviceScaleFactor();
1502 }
1503
1504 void DOMWindow::scrollBy(int x, int y) const
1505 {
1506     if (!isCurrentlyDisplayedInFrame())
1507         return;
1508
1509     document()->updateLayoutIgnorePendingStylesheets();
1510
1511     FrameView* view = m_frame->view();
1512     if (!view)
1513         return;
1514
1515     IntSize scaledOffset(view->mapFromCSSToLayoutUnits(x), view->mapFromCSSToLayoutUnits(y));
1516     view->setContentsScrollPosition(view->contentsScrollPosition() + scaledOffset);
1517 }
1518
1519 void DOMWindow::scrollTo(int x, int y) const
1520 {
1521     if (!isCurrentlyDisplayedInFrame())
1522         return;
1523
1524     RefPtr<FrameView> view = m_frame->view();
1525     if (!view)
1526         return;
1527
1528     if (!x && !y && view->contentsScrollPosition() == IntPoint(0, 0))
1529         return;
1530
1531     document()->updateLayoutIgnorePendingStylesheets();
1532
1533     IntPoint layoutPos(view->mapFromCSSToLayoutUnits(x), view->mapFromCSSToLayoutUnits(y));
1534     view->setContentsScrollPosition(layoutPos);
1535 }
1536
1537 bool DOMWindow::allowedToChangeWindowGeometry() const
1538 {
1539     if (!m_frame)
1540         return false;
1541     if (!m_frame->page())
1542         return false;
1543     if (!m_frame->isMainFrame())
1544         return false;
1545     // Prevent web content from tricking the user into initiating a drag.
1546     if (m_frame->eventHandler().mousePressed())
1547         return false;
1548     return true;
1549 }
1550
1551 void DOMWindow::moveBy(float x, float y) const
1552 {
1553     if (!allowedToChangeWindowGeometry())
1554         return;
1555
1556     Page* page = m_frame->page();
1557     FloatRect fr = page->chrome().windowRect();
1558     FloatRect update = fr;
1559     update.move(x, y);
1560     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
1561     page->chrome().setWindowRect(adjustWindowRect(page, update));
1562 }
1563
1564 void DOMWindow::moveTo(float x, float y) const
1565 {
1566     if (!allowedToChangeWindowGeometry())
1567         return;
1568
1569     Page* page = m_frame->page();
1570     FloatRect fr = page->chrome().windowRect();
1571     FloatRect sr = screenAvailableRect(page->mainFrame().view());
1572     fr.setLocation(sr.location());
1573     FloatRect update = fr;
1574     update.move(x, y);
1575     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
1576     page->chrome().setWindowRect(adjustWindowRect(page, update));
1577 }
1578
1579 void DOMWindow::resizeBy(float x, float y) const
1580 {
1581     if (!allowedToChangeWindowGeometry())
1582         return;
1583
1584     Page* page = m_frame->page();
1585     FloatRect fr = page->chrome().windowRect();
1586     FloatSize dest = fr.size() + FloatSize(x, y);
1587     FloatRect update(fr.location(), dest);
1588     page->chrome().setWindowRect(adjustWindowRect(page, update));
1589 }
1590
1591 void DOMWindow::resizeTo(float width, float height) const
1592 {
1593     if (!allowedToChangeWindowGeometry())
1594         return;
1595
1596     Page* page = m_frame->page();
1597     FloatRect fr = page->chrome().windowRect();
1598     FloatSize dest = FloatSize(width, height);
1599     FloatRect update(fr.location(), dest);
1600     page->chrome().setWindowRect(adjustWindowRect(page, update));
1601 }
1602
1603 int DOMWindow::setTimeout(std::unique_ptr<ScheduledAction> action, int timeout, ExceptionCode& ec)
1604 {
1605     ScriptExecutionContext* context = scriptExecutionContext();
1606     if (!context) {
1607         ec = INVALID_ACCESS_ERR;
1608         return -1;
1609     }
1610     return DOMTimer::install(*context, WTF::move(action), timeout, true);
1611 }
1612
1613 void DOMWindow::clearTimeout(int timeoutId)
1614 {
1615 #if PLATFORM(IOS)
1616     if (m_frame) {
1617         Document* document = m_frame->document();
1618         if (timeoutId > 0 && document) {
1619             DOMTimer* timer = document->findTimeout(timeoutId);
1620             if (timer && WebThreadContainsObservedContentModifier(timer)) {
1621                 WebThreadRemoveObservedContentModifier(timer);
1622
1623                 if (!WebThreadCountOfObservedContentModifiers()) {
1624                     if (Page* page = m_frame->page())
1625                         page->chrome().client().observedContentChange(m_frame);
1626                 }
1627             }
1628         }
1629     }
1630 #endif
1631     ScriptExecutionContext* context = scriptExecutionContext();
1632     if (!context)
1633         return;
1634     DOMTimer::removeById(*context, timeoutId);
1635 }
1636
1637 int DOMWindow::setInterval(std::unique_ptr<ScheduledAction> action, int timeout, ExceptionCode& ec)
1638 {
1639     ScriptExecutionContext* context = scriptExecutionContext();
1640     if (!context) {
1641         ec = INVALID_ACCESS_ERR;
1642         return -1;
1643     }
1644     return DOMTimer::install(*context, WTF::move(action), timeout, false);
1645 }
1646
1647 void DOMWindow::clearInterval(int timeoutId)
1648 {
1649     ScriptExecutionContext* context = scriptExecutionContext();
1650     if (!context)
1651         return;
1652     DOMTimer::removeById(*context, timeoutId);
1653 }
1654
1655 #if ENABLE(REQUEST_ANIMATION_FRAME)
1656 int DOMWindow::requestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback> callback)
1657 {
1658     callback->m_useLegacyTimeBase = false;
1659     if (Document* d = document())
1660         return d->requestAnimationFrame(callback);
1661     return 0;
1662 }
1663
1664 int DOMWindow::webkitRequestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback> callback)
1665 {
1666     callback->m_useLegacyTimeBase = true;
1667     if (Document* d = document())
1668         return d->requestAnimationFrame(callback);
1669     return 0;
1670 }
1671
1672 void DOMWindow::cancelAnimationFrame(int id)
1673 {
1674     if (Document* d = document())
1675         d->cancelAnimationFrame(id);
1676 }
1677 #endif
1678
1679 DOMWindowCSS* DOMWindow::css()
1680 {
1681     if (!m_css)
1682         m_css = DOMWindowCSS::create();
1683     return m_css.get();
1684 }
1685
1686 static void didAddStorageEventListener(DOMWindow* window)
1687 {
1688     // Creating these WebCore::Storage objects informs the system that we'd like to receive
1689     // notifications about storage events that might be triggered in other processes. Rather
1690     // than subscribe to these notifications explicitly, we subscribe to them implicitly to
1691     // simplify the work done by the system. 
1692     window->localStorage(IGNORE_EXCEPTION);
1693     window->sessionStorage(IGNORE_EXCEPTION);
1694 }
1695
1696 bool DOMWindow::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
1697 {
1698     if (!EventTarget::addEventListener(eventType, listener, useCapture))
1699         return false;
1700
1701     if (Document* document = this->document()) {
1702         document->addListenerTypeIfNeeded(eventType);
1703         if (eventNames().isWheelEventType(eventType))
1704             document->didAddWheelEventHandler(*document);
1705         else if (eventNames().isTouchEventType(eventType))
1706             document->didAddTouchEventHandler(*document);
1707         else if (eventType == eventNames().storageEvent)
1708             didAddStorageEventListener(this);
1709     }
1710
1711     if (eventType == eventNames().unloadEvent)
1712         addUnloadEventListener(this);
1713     else if (eventType == eventNames().beforeunloadEvent && allowsBeforeUnloadListeners(this))
1714         addBeforeUnloadEventListener(this);
1715 #if ENABLE(DEVICE_ORIENTATION)
1716 #if PLATFORM(IOS)
1717     else if (eventType == eventNames().devicemotionEvent && document())
1718         document()->deviceMotionController()->addDeviceEventListener(this);
1719     else if (eventType == eventNames().deviceorientationEvent && document())
1720         document()->deviceOrientationController()->addDeviceEventListener(this);
1721 #else
1722     else if (eventType == eventNames().devicemotionEvent && RuntimeEnabledFeatures::sharedFeatures().deviceMotionEnabled()) {
1723         if (DeviceMotionController* controller = DeviceMotionController::from(page()))
1724             controller->addDeviceEventListener(this);
1725     } else if (eventType == eventNames().deviceorientationEvent && RuntimeEnabledFeatures::sharedFeatures().deviceOrientationEnabled()) {
1726         if (DeviceOrientationController* controller = DeviceOrientationController::from(page()))
1727             controller->addDeviceEventListener(this);
1728     }
1729 #endif // PLATFORM(IOS)
1730 #endif // ENABLE(DEVICE_ORIENTATION)
1731 #if PLATFORM(IOS)
1732     else if (eventType == eventNames().scrollEvent)
1733         incrementScrollEventListenersCount();
1734 #endif
1735 #if ENABLE(IOS_TOUCH_EVENTS)
1736     else if (eventNames().isTouchEventType(eventType))
1737         ++m_touchEventListenerCount;
1738 #endif
1739 #if ENABLE(IOS_GESTURE_EVENTS)
1740     else if (eventNames().isGestureEventType(eventType))
1741         ++m_touchEventListenerCount;
1742 #endif
1743 #if ENABLE(GAMEPAD)
1744     else if (eventNames().isGamepadEventType(eventType))
1745         incrementGamepadEventListenerCount();
1746 #endif
1747 #if ENABLE(PROXIMITY_EVENTS)
1748     else if (eventType == eventNames().webkitdeviceproximityEvent) {
1749         if (DeviceProximityController* controller = DeviceProximityController::from(page()))
1750             controller->addDeviceEventListener(this);
1751     }
1752 #endif
1753
1754     return true;
1755 }
1756
1757 #if PLATFORM(IOS)
1758 void DOMWindow::incrementScrollEventListenersCount()
1759 {
1760     Document* document = this->document();
1761     if (++m_scrollEventListenerCount == 1 && document == &document->topDocument()) {
1762         Frame* frame = this->frame();
1763         if (frame && frame->page())
1764             frame->page()->chrome().client().setNeedsScrollNotifications(frame, true);
1765     }
1766 }
1767
1768 void DOMWindow::decrementScrollEventListenersCount()
1769 {
1770     Document* document = this->document();
1771     if (!--m_scrollEventListenerCount && document == &document->topDocument()) {
1772         Frame* frame = this->frame();
1773         if (frame && frame->page() && !document->inPageCache())
1774             frame->page()->chrome().client().setNeedsScrollNotifications(frame, false);
1775     }
1776 }
1777 #endif
1778
1779 void DOMWindow::resetAllGeolocationPermission()
1780 {
1781     // FIXME: Remove PLATFORM(IOS)-guard once we upstream the iOS changes to Geolocation.cpp.
1782 #if ENABLE(GEOLOCATION) && PLATFORM(IOS)
1783     if (m_navigator)
1784         NavigatorGeolocation::from(m_navigator.get())->resetAllGeolocationPermission();
1785 #endif
1786 }
1787
1788 bool DOMWindow::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
1789 {
1790     if (!EventTarget::removeEventListener(eventType, listener, useCapture))
1791         return false;
1792
1793     if (Document* document = this->document()) {
1794         if (eventNames().isWheelEventType(eventType))
1795             document->didRemoveWheelEventHandler(*document);
1796         else if (eventNames().isTouchEventType(eventType))
1797             document->didRemoveTouchEventHandler(*document);
1798     }
1799
1800     if (eventType == eventNames().unloadEvent)
1801         removeUnloadEventListener(this);
1802     else if (eventType == eventNames().beforeunloadEvent && allowsBeforeUnloadListeners(this))
1803         removeBeforeUnloadEventListener(this);
1804 #if ENABLE(DEVICE_ORIENTATION)
1805 #if PLATFORM(IOS)
1806     else if (eventType == eventNames().devicemotionEvent && document())
1807         document()->deviceMotionController()->removeDeviceEventListener(this);
1808     else if (eventType == eventNames().deviceorientationEvent && document())
1809         document()->deviceOrientationController()->removeDeviceEventListener(this);
1810 #else
1811     else if (eventType == eventNames().devicemotionEvent) {
1812         if (DeviceMotionController* controller = DeviceMotionController::from(page()))
1813             controller->removeDeviceEventListener(this);
1814     } else if (eventType == eventNames().deviceorientationEvent) {
1815         if (DeviceOrientationController* controller = DeviceOrientationController::from(page()))
1816             controller->removeDeviceEventListener(this);
1817     }
1818 #endif // PLATFORM(IOS)
1819 #endif // ENABLE(DEVICE_ORIENTATION)
1820 #if PLATFORM(IOS)
1821     else if (eventType == eventNames().scrollEvent)
1822         decrementScrollEventListenersCount();
1823 #endif
1824 #if ENABLE(IOS_TOUCH_EVENTS)
1825     else if (eventNames().isTouchEventType(eventType)) {
1826         ASSERT(m_touchEventListenerCount > 0);
1827         --m_touchEventListenerCount;
1828     }
1829 #endif
1830 #if ENABLE(IOS_GESTURE_EVENTS)
1831     else if (eventNames().isGestureEventType(eventType)) {
1832         ASSERT(m_touchEventListenerCount > 0);
1833         --m_touchEventListenerCount;
1834     }
1835 #endif
1836 #if ENABLE(GAMEPAD)
1837     else if (eventNames().isGamepadEventType(eventType))
1838         decrementGamepadEventListenerCount();
1839 #endif
1840 #if ENABLE(PROXIMITY_EVENTS)
1841     else if (eventType == eventNames().webkitdeviceproximityEvent) {
1842         if (DeviceProximityController* controller = DeviceProximityController::from(page()))
1843             controller->removeDeviceEventListener(this);
1844     }
1845 #endif
1846
1847     return true;
1848 }
1849
1850 void DOMWindow::dispatchLoadEvent()
1851 {
1852     RefPtr<Event> loadEvent(Event::create(eventNames().loadEvent, false, false));
1853     if (m_frame && m_frame->loader().documentLoader() && !m_frame->loader().documentLoader()->timing().loadEventStart()) {
1854         // The DocumentLoader (and thus its DocumentLoadTiming) might get destroyed while dispatching
1855         // the event, so protect it to prevent writing the end time into freed memory.
1856         RefPtr<DocumentLoader> documentLoader = m_frame->loader().documentLoader();
1857         DocumentLoadTiming& timing = documentLoader->timing();
1858         timing.markLoadEventStart();
1859         dispatchEvent(loadEvent, document());
1860         timing.markLoadEventEnd();
1861     } else
1862         dispatchEvent(loadEvent, document());
1863
1864     // For load events, send a separate load event to the enclosing frame only.
1865     // This is a DOM extension and is independent of bubbling/capturing rules of
1866     // the DOM.
1867     Element* ownerElement = m_frame ? m_frame->ownerElement() : nullptr;
1868     if (ownerElement)
1869         ownerElement->dispatchEvent(Event::create(eventNames().loadEvent, false, false));
1870
1871     InspectorInstrumentation::loadEventFired(frame());
1872 }
1873
1874 bool DOMWindow::dispatchEvent(PassRefPtr<Event> prpEvent, PassRefPtr<EventTarget> prpTarget)
1875 {
1876     Ref<EventTarget> protect(*this);
1877     RefPtr<Event> event = prpEvent;
1878
1879     // Pausing a page may trigger pagehide and pageshow events. WebCore also implicitly fires these
1880     // events when closing a WebView. Here we keep track of the state of the page to prevent duplicate,
1881     // unbalanced events per the definition of the pageshow event:
1882     // <http://www.whatwg.org/specs/web-apps/current-work/multipage/history.html#event-pageshow>.
1883     if (event->eventInterface() == PageTransitionEventInterfaceType) {
1884         if (event->type() == eventNames().pageshowEvent) {
1885             if (m_lastPageStatus == PageStatusShown)
1886                 return true; // Event was previously dispatched; do not fire a duplicate event.
1887             m_lastPageStatus = PageStatusShown;
1888         } else if (event->type() == eventNames().pagehideEvent) {
1889             if (m_lastPageStatus == PageStatusHidden)
1890                 return true; // Event was previously dispatched; do not fire a duplicate event.
1891             m_lastPageStatus = PageStatusHidden;
1892         }
1893     }
1894
1895     event->setTarget(prpTarget ? prpTarget : this);
1896     event->setCurrentTarget(this);
1897     event->setEventPhase(Event::AT_TARGET);
1898
1899     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willDispatchEventOnWindow(frame(), *event, *this);
1900
1901     bool result = fireEventListeners(event.get());
1902
1903     InspectorInstrumentation::didDispatchEventOnWindow(cookie);
1904
1905     return result;
1906 }
1907
1908 void DOMWindow::removeAllEventListeners()
1909 {
1910     EventTarget::removeAllEventListeners();
1911
1912 #if ENABLE(DEVICE_ORIENTATION)
1913 #if PLATFORM(IOS)
1914     if (Document* document = this->document()) {
1915         document->deviceMotionController()->removeAllDeviceEventListeners(this);
1916         document->deviceOrientationController()->removeAllDeviceEventListeners(this);
1917     }
1918 #else
1919     if (DeviceMotionController* controller = DeviceMotionController::from(page()))
1920         controller->removeAllDeviceEventListeners(this);
1921     if (DeviceOrientationController* controller = DeviceOrientationController::from(page()))
1922         controller->removeAllDeviceEventListeners(this);
1923 #endif // PLATFORM(IOS)
1924 #endif // ENABLE(DEVICE_ORIENTATION)
1925
1926 #if PLATFORM(IOS)
1927     if (m_scrollEventListenerCount) {
1928         m_scrollEventListenerCount = 1;
1929         decrementScrollEventListenersCount();
1930     }
1931 #endif
1932
1933 #if ENABLE(IOS_TOUCH_EVENTS) || ENABLE(IOS_GESTURE_EVENTS)
1934     m_touchEventListenerCount = 0;
1935 #endif
1936
1937 #if ENABLE(TOUCH_EVENTS)
1938     if (Document* document = this->document())
1939         document->didRemoveEventTargetNode(*document);
1940 #endif
1941
1942 #if ENABLE(PROXIMITY_EVENTS)
1943     if (DeviceProximityController* controller = DeviceProximityController::from(page()))
1944         controller->removeAllDeviceEventListeners(this);
1945 #endif
1946
1947     removeAllUnloadEventListeners(this);
1948     removeAllBeforeUnloadEventListeners(this);
1949 }
1950
1951 void DOMWindow::captureEvents()
1952 {
1953     // Not implemented.
1954 }
1955
1956 void DOMWindow::releaseEvents()
1957 {
1958     // Not implemented.
1959 }
1960
1961 void DOMWindow::finishedLoading()
1962 {
1963     if (m_shouldPrintWhenFinishedLoading) {
1964         m_shouldPrintWhenFinishedLoading = false;
1965         print();
1966     }
1967 }
1968
1969 void DOMWindow::setLocation(const String& urlString, DOMWindow& activeWindow, DOMWindow& firstWindow, SetLocationLocking locking)
1970 {
1971     if (!isCurrentlyDisplayedInFrame())
1972         return;
1973
1974     Document* activeDocument = activeWindow.document();
1975     if (!activeDocument)
1976         return;
1977
1978     if (!activeDocument->canNavigate(m_frame))
1979         return;
1980
1981     Frame* firstFrame = firstWindow.frame();
1982     if (!firstFrame)
1983         return;
1984
1985     URL completedURL = firstFrame->document()->completeURL(urlString);
1986     if (completedURL.isNull())
1987         return;
1988
1989     if (isInsecureScriptAccess(activeWindow, completedURL))
1990         return;
1991
1992     // We want a new history item if we are processing a user gesture.
1993     LockHistory lockHistory = (locking != LockHistoryBasedOnGestureState || !ScriptController::processingUserGesture()) ? LockHistory::Yes : LockHistory::No;
1994     LockBackForwardList lockBackForwardList = (locking != LockHistoryBasedOnGestureState) ? LockBackForwardList::Yes : LockBackForwardList::No;
1995     m_frame->navigationScheduler().scheduleLocationChange(activeDocument->securityOrigin(),
1996         // FIXME: What if activeDocument()->frame() is 0?
1997         completedURL, activeDocument->frame()->loader().outgoingReferrer(),
1998         lockHistory, lockBackForwardList);
1999 }
2000
2001 void DOMWindow::printErrorMessage(const String& message)
2002 {
2003     if (message.isEmpty())
2004         return;
2005
2006     if (PageConsoleClient* pageConsole = console())
2007         pageConsole->addMessage(MessageSource::JS, MessageLevel::Error, message);
2008 }
2009
2010 String DOMWindow::crossDomainAccessErrorMessage(const DOMWindow& activeWindow)
2011 {
2012     const URL& activeWindowURL = activeWindow.document()->url();
2013     if (activeWindowURL.isNull())
2014         return String();
2015
2016     ASSERT(!activeWindow.document()->securityOrigin()->canAccess(document()->securityOrigin()));
2017
2018     // FIXME: This message, and other console messages, have extra newlines. Should remove them.
2019     SecurityOrigin* activeOrigin = activeWindow.document()->securityOrigin();
2020     SecurityOrigin* targetOrigin = document()->securityOrigin();
2021     String message = "Blocked a frame with origin \"" + activeOrigin->toString() + "\" from accessing a frame with origin \"" + targetOrigin->toString() + "\". ";
2022
2023     // Sandbox errors: Use the origin of the frames' location, rather than their actual origin (since we know that at least one will be "null").
2024     URL activeURL = activeWindow.document()->url();
2025     URL targetURL = document()->url();
2026     if (document()->isSandboxed(SandboxOrigin) || activeWindow.document()->isSandboxed(SandboxOrigin)) {
2027         message = "Blocked a frame at \"" + SecurityOrigin::create(activeURL).get().toString() + "\" from accessing a frame at \"" + SecurityOrigin::create(targetURL).get().toString() + "\". ";
2028         if (document()->isSandboxed(SandboxOrigin) && activeWindow.document()->isSandboxed(SandboxOrigin))
2029             return "Sandbox access violation: " + message + " Both frames are sandboxed and lack the \"allow-same-origin\" flag.";
2030         if (document()->isSandboxed(SandboxOrigin))
2031             return "Sandbox access violation: " + message + " The frame being accessed is sandboxed and lacks the \"allow-same-origin\" flag.";
2032         return "Sandbox access violation: " + message + " The frame requesting access is sandboxed and lacks the \"allow-same-origin\" flag.";
2033     }
2034
2035     // Protocol errors: Use the URL's protocol rather than the origin's protocol so that we get a useful message for non-heirarchal URLs like 'data:'.
2036     if (targetOrigin->protocol() != activeOrigin->protocol())
2037         return message + " The frame requesting access has a protocol of \"" + activeURL.protocol() + "\", the frame being accessed has a protocol of \"" + targetURL.protocol() + "\". Protocols must match.\n";
2038
2039     // 'document.domain' errors.
2040     if (targetOrigin->domainWasSetInDOM() && activeOrigin->domainWasSetInDOM())
2041         return message + "The frame requesting access set \"document.domain\" to \"" + activeOrigin->domain() + "\", the frame being accessed set it to \"" + targetOrigin->domain() + "\". Both must set \"document.domain\" to the same value to allow access.";
2042     if (activeOrigin->domainWasSetInDOM())
2043         return message + "The frame requesting access set \"document.domain\" to \"" + activeOrigin->domain() + "\", but the frame being accessed did not. Both must set \"document.domain\" to the same value to allow access.";
2044     if (targetOrigin->domainWasSetInDOM())
2045         return message + "The frame being accessed set \"document.domain\" to \"" + targetOrigin->domain() + "\", but the frame requesting access did not. Both must set \"document.domain\" to the same value to allow access.";
2046
2047     // Default.
2048     return message + "Protocols, domains, and ports must match.";
2049 }
2050
2051 bool DOMWindow::isInsecureScriptAccess(DOMWindow& activeWindow, const String& urlString)
2052 {
2053     if (!protocolIsJavaScript(urlString))
2054         return false;
2055
2056     // If this DOMWindow isn't currently active in the Frame, then there's no
2057     // way we should allow the access.
2058     // FIXME: Remove this check if we're able to disconnect DOMWindow from
2059     // Frame on navigation: https://bugs.webkit.org/show_bug.cgi?id=62054
2060     if (isCurrentlyDisplayedInFrame()) {
2061         // FIXME: Is there some way to eliminate the need for a separate "activeWindow == this" check?
2062         if (&activeWindow == this)
2063             return false;
2064
2065         // FIXME: The name canAccess seems to be a roundabout way to ask "can execute script".
2066         // Can we name the SecurityOrigin function better to make this more clear?
2067         if (activeWindow.document()->securityOrigin()->canAccess(document()->securityOrigin()))
2068             return false;
2069     }
2070
2071     printErrorMessage(crossDomainAccessErrorMessage(activeWindow));
2072     return true;
2073 }
2074
2075 PassRefPtr<Frame> DOMWindow::createWindow(const String& urlString, const AtomicString& frameName, const WindowFeatures& windowFeatures, DOMWindow& activeWindow, Frame* firstFrame, Frame* openerFrame, std::function<void (DOMWindow&)> prepareDialogFunction)
2076 {
2077     Frame* activeFrame = activeWindow.frame();
2078
2079     URL completedURL = urlString.isEmpty() ? URL(ParsedURLString, emptyString()) : firstFrame->document()->completeURL(urlString);
2080     if (!completedURL.isEmpty() && !completedURL.isValid()) {
2081         // Don't expose client code to invalid URLs.
2082         activeWindow.printErrorMessage("Unable to open a window with invalid URL '" + completedURL.string() + "'.\n");
2083         return 0;
2084     }
2085
2086     // For whatever reason, Firefox uses the first frame to determine the outgoingReferrer. We replicate that behavior here.
2087     String referrer = SecurityPolicy::generateReferrerHeader(firstFrame->document()->referrerPolicy(), completedURL, firstFrame->loader().outgoingReferrer());
2088
2089     ResourceRequest request(completedURL, referrer);
2090     FrameLoader::addHTTPOriginIfNeeded(request, firstFrame->loader().outgoingOrigin());
2091     FrameLoadRequest frameRequest(activeWindow.document()->securityOrigin(), request, frameName);
2092
2093     // We pass the opener frame for the lookupFrame in case the active frame is different from
2094     // the opener frame, and the name references a frame relative to the opener frame.
2095     bool created;
2096     RefPtr<Frame> newFrame = WebCore::createWindow(activeFrame, openerFrame, frameRequest, windowFeatures, created);
2097     if (!newFrame)
2098         return 0;
2099
2100     newFrame->loader().setOpener(openerFrame);
2101     newFrame->page()->setOpenedByDOM();
2102
2103     if (newFrame->document()->domWindow()->isInsecureScriptAccess(activeWindow, completedURL))
2104         return newFrame.release();
2105
2106     if (prepareDialogFunction)
2107         prepareDialogFunction(*newFrame->document()->domWindow());
2108
2109     if (created)
2110         newFrame->loader().changeLocation(activeWindow.document()->securityOrigin(), completedURL, referrer, LockHistory::No, LockBackForwardList::No);
2111     else if (!urlString.isEmpty()) {
2112         LockHistory lockHistory = ScriptController::processingUserGesture() ? LockHistory::No : LockHistory::Yes;
2113         newFrame->navigationScheduler().scheduleLocationChange(activeWindow.document()->securityOrigin(), completedURL, referrer, lockHistory, LockBackForwardList::No);
2114     }
2115
2116     // Navigating the new frame could result in it being detached from its page by a navigation policy delegate.
2117     if (!newFrame->page())
2118         return 0;
2119
2120     return newFrame.release();
2121 }
2122
2123 PassRefPtr<DOMWindow> DOMWindow::open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
2124     DOMWindow& activeWindow, DOMWindow& firstWindow)
2125 {
2126     if (!isCurrentlyDisplayedInFrame())
2127         return nullptr;
2128     Document* activeDocument = activeWindow.document();
2129     if (!activeDocument)
2130         return nullptr;
2131     Frame* firstFrame = firstWindow.frame();
2132     if (!firstFrame)
2133         return nullptr;
2134
2135 #if ENABLE(CONTENT_EXTENSIONS)
2136     if (firstFrame
2137         && firstFrame->document()
2138         && firstFrame->mainFrame().page()
2139         && firstFrame->mainFrame().page()->userContentController()
2140         && firstFrame->mainFrame().document()) {
2141         ResourceLoadInfo resourceLoadInfo = {firstFrame->document()->completeURL(urlString), firstFrame->mainFrame().document()->url(), ResourceType::Popup};
2142         Vector<ContentExtensions::Action> actions = firstFrame->mainFrame().page()->userContentController()->actionsForResourceLoad(resourceLoadInfo);
2143         for (const ContentExtensions::Action& action : actions) {
2144             if (action.type() == ContentExtensions::ActionType::BlockLoad)
2145                 return nullptr;
2146         }
2147     }
2148 #endif
2149
2150     if (!firstWindow.allowPopUp()) {
2151         // Because FrameTree::find() returns true for empty strings, we must check for empty frame names.
2152         // Otherwise, illegitimate window.open() calls with no name will pass right through the popup blocker.
2153         if (frameName.isEmpty() || !m_frame->tree().find(frameName))
2154             return nullptr;
2155     }
2156
2157     // Get the target frame for the special cases of _top and _parent.
2158     // In those cases, we schedule a location change right now and return early.
2159     Frame* targetFrame = nullptr;
2160     if (frameName == "_top")
2161         targetFrame = &m_frame->tree().top();
2162     else if (frameName == "_parent") {
2163         if (Frame* parent = m_frame->tree().parent())
2164             targetFrame = parent;
2165         else
2166             targetFrame = m_frame;
2167     }
2168     if (targetFrame) {
2169         if (!activeDocument->canNavigate(targetFrame))
2170             return nullptr;
2171
2172         URL completedURL = firstFrame->document()->completeURL(urlString);
2173
2174         if (targetFrame->document()->domWindow()->isInsecureScriptAccess(activeWindow, completedURL))
2175             return targetFrame->document()->domWindow();
2176
2177         if (urlString.isEmpty())
2178             return targetFrame->document()->domWindow();
2179
2180         // For whatever reason, Firefox uses the first window rather than the active window to
2181         // determine the outgoing referrer. We replicate that behavior here.
2182         LockHistory lockHistory = ScriptController::processingUserGesture() ? LockHistory::No : LockHistory::Yes;
2183         targetFrame->navigationScheduler().scheduleLocationChange(activeDocument->securityOrigin(), completedURL, firstFrame->loader().outgoingReferrer(),
2184             lockHistory, LockBackForwardList::No);
2185         return targetFrame->document()->domWindow();
2186     }
2187
2188     WindowFeatures windowFeatures(windowFeaturesString);
2189     RefPtr<Frame> result = createWindow(urlString, frameName, windowFeatures, activeWindow, firstFrame, m_frame);
2190     return result ? result->document()->domWindow() : nullptr;
2191 }
2192
2193 void DOMWindow::showModalDialog(const String& urlString, const String& dialogFeaturesString, DOMWindow& activeWindow, DOMWindow& firstWindow, std::function<void (DOMWindow&)> prepareDialogFunction)
2194 {
2195     if (!isCurrentlyDisplayedInFrame())
2196         return;
2197     Frame* activeFrame = activeWindow.frame();
2198     if (!activeFrame)
2199         return;
2200     Frame* firstFrame = firstWindow.frame();
2201     if (!firstFrame)
2202         return;
2203
2204     // Pages are not allowed to cause modal alerts during BeforeUnload dispatch.
2205     if (page() && page()->isAnyFrameHandlingBeforeUnloadEvent()) {
2206         printErrorMessage("Use of window.showModalDialog is not allowed during beforeunload event dispatch.");
2207         return;
2208     }
2209
2210     if (!canShowModalDialogNow(m_frame) || !firstWindow.allowPopUp())
2211         return;
2212
2213     WindowFeatures windowFeatures(dialogFeaturesString, screenAvailableRect(m_frame->view()));
2214     RefPtr<Frame> dialogFrame = createWindow(urlString, emptyAtom, windowFeatures, activeWindow, firstFrame, m_frame, WTF::move(prepareDialogFunction));
2215     if (!dialogFrame)
2216         return;
2217     dialogFrame->page()->chrome().runModal();
2218 }
2219
2220 void DOMWindow::enableSuddenTermination()
2221 {
2222     if (Page* page = this->page())
2223         page->chrome().enableSuddenTermination();
2224 }
2225
2226 void DOMWindow::disableSuddenTermination()
2227 {
2228     if (Page* page = this->page())
2229         page->chrome().disableSuddenTermination();
2230 }
2231
2232 } // namespace WebCore