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