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