4d83342e24c5c202c6181657c03ed2ddb7d544bb
[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 = static_cast<Document*>(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 = static_cast<Document*>(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     ASSERT_WITH_SECURITY_IMPLICATION(!context || context->isDocument());
1327     return static_cast<Document*>(context);
1328 }
1329
1330 PassRefPtr<StyleMedia> DOMWindow::styleMedia() const
1331 {
1332     if (!isCurrentlyDisplayedInFrame())
1333         return 0;
1334     if (!m_media)
1335         m_media = StyleMedia::create(m_frame);
1336     return m_media.get();
1337 }
1338
1339 PassRefPtr<CSSStyleDeclaration> DOMWindow::getComputedStyle(Element* elt, const String& pseudoElt) const
1340 {
1341     if (!elt)
1342         return 0;
1343
1344     return CSSComputedStyleDeclaration::create(elt, false, pseudoElt);
1345 }
1346
1347 PassRefPtr<CSSRuleList> DOMWindow::getMatchedCSSRules(Element* element, const String& pseudoElement, bool authorOnly) const
1348 {
1349     if (!isCurrentlyDisplayedInFrame())
1350         return 0;
1351
1352     unsigned colonStart = pseudoElement[0] == ':' ? (pseudoElement[1] == ':' ? 2 : 1) : 0;
1353     CSSSelector::PseudoType pseudoType = CSSSelector::parsePseudoType(AtomicString(pseudoElement.substring(colonStart)));
1354     if (pseudoType == CSSSelector::PseudoUnknown && !pseudoElement.isEmpty())
1355         return 0;
1356
1357     unsigned rulesToInclude = StyleResolver::AuthorCSSRules;
1358     if (!authorOnly)
1359         rulesToInclude |= StyleResolver::UAAndUserCSSRules;
1360     if (Settings* settings = m_frame->settings()) {
1361         if (settings->crossOriginCheckInGetMatchedCSSRulesDisabled())
1362             rulesToInclude |= StyleResolver::CrossOriginCSSRules;
1363     }
1364
1365     PseudoId pseudoId = CSSSelector::pseudoId(pseudoType);
1366
1367     return m_frame->document()->styleResolver()->pseudoStyleRulesForElement(element, pseudoId, rulesToInclude);
1368 }
1369
1370 PassRefPtr<WebKitPoint> DOMWindow::webkitConvertPointFromNodeToPage(Node* node, const WebKitPoint* p) const
1371 {
1372     if (!node || !p)
1373         return 0;
1374
1375     if (!document())
1376         return 0;
1377
1378     document()->updateLayoutIgnorePendingStylesheets();
1379
1380     FloatPoint pagePoint(p->x(), p->y());
1381     pagePoint = node->convertToPage(pagePoint);
1382     return WebKitPoint::create(pagePoint.x(), pagePoint.y());
1383 }
1384
1385 PassRefPtr<WebKitPoint> DOMWindow::webkitConvertPointFromPageToNode(Node* node, const WebKitPoint* p) const
1386 {
1387     if (!node || !p)
1388         return 0;
1389
1390     if (!document())
1391         return 0;
1392
1393     document()->updateLayoutIgnorePendingStylesheets();
1394
1395     FloatPoint nodePoint(p->x(), p->y());
1396     nodePoint = node->convertFromPage(nodePoint);
1397     return WebKitPoint::create(nodePoint.x(), nodePoint.y());
1398 }
1399
1400 double DOMWindow::devicePixelRatio() const
1401 {
1402     if (!m_frame)
1403         return 0.0;
1404
1405     Page* page = m_frame->page();
1406     if (!page)
1407         return 0.0;
1408
1409     return page->deviceScaleFactor();
1410 }
1411
1412 void DOMWindow::scrollBy(int x, int y) const
1413 {
1414     if (!isCurrentlyDisplayedInFrame())
1415         return;
1416
1417     document()->updateLayoutIgnorePendingStylesheets();
1418
1419     FrameView* view = m_frame->view();
1420     if (!view)
1421         return;
1422
1423     IntSize scaledOffset(view->mapFromCSSToLayoutUnits(x), view->mapFromCSSToLayoutUnits(y));
1424     view->scrollBy(scaledOffset);
1425 }
1426
1427 void DOMWindow::scrollTo(int x, int y) const
1428 {
1429     if (!isCurrentlyDisplayedInFrame())
1430         return;
1431
1432     document()->updateLayoutIgnorePendingStylesheets();
1433
1434     RefPtr<FrameView> view = m_frame->view();
1435     if (!view)
1436         return;
1437
1438     IntPoint layoutPos(view->mapFromCSSToLayoutUnits(x), view->mapFromCSSToLayoutUnits(y));
1439     view->setScrollPosition(layoutPos);
1440 }
1441
1442 void DOMWindow::moveBy(float x, float y) const
1443 {
1444     if (!m_frame)
1445         return;
1446
1447     Page* page = m_frame->page();
1448     if (!page)
1449         return;
1450
1451     if (m_frame != page->mainFrame())
1452         return;
1453
1454     FloatRect fr = page->chrome()->windowRect();
1455     FloatRect update = fr;
1456     update.move(x, y);
1457     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
1458     page->chrome()->setWindowRect(adjustWindowRect(page, update));
1459 }
1460
1461 void DOMWindow::moveTo(float x, float y) const
1462 {
1463     if (!m_frame)
1464         return;
1465
1466     Page* page = m_frame->page();
1467     if (!page)
1468         return;
1469
1470     if (m_frame != page->mainFrame())
1471         return;
1472
1473     FloatRect fr = page->chrome()->windowRect();
1474     FloatRect sr = screenAvailableRect(page->mainFrame()->view());
1475     fr.setLocation(sr.location());
1476     FloatRect update = fr;
1477     update.move(x, y);
1478     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
1479     page->chrome()->setWindowRect(adjustWindowRect(page, update));
1480 }
1481
1482 void DOMWindow::resizeBy(float x, float y) const
1483 {
1484     if (!m_frame)
1485         return;
1486
1487     Page* page = m_frame->page();
1488     if (!page)
1489         return;
1490
1491     if (m_frame != page->mainFrame())
1492         return;
1493
1494     FloatRect fr = page->chrome()->windowRect();
1495     FloatSize dest = fr.size() + FloatSize(x, y);
1496     FloatRect update(fr.location(), dest);
1497     page->chrome()->setWindowRect(adjustWindowRect(page, update));
1498 }
1499
1500 void DOMWindow::resizeTo(float width, float height) const
1501 {
1502     if (!m_frame)
1503         return;
1504
1505     Page* page = m_frame->page();
1506     if (!page)
1507         return;
1508
1509     if (m_frame != page->mainFrame())
1510         return;
1511
1512     FloatRect fr = page->chrome()->windowRect();
1513     FloatSize dest = FloatSize(width, height);
1514     FloatRect update(fr.location(), dest);
1515     page->chrome()->setWindowRect(adjustWindowRect(page, update));
1516 }
1517
1518 int DOMWindow::setTimeout(PassOwnPtr<ScheduledAction> action, int timeout, ExceptionCode& ec)
1519 {
1520     ScriptExecutionContext* context = scriptExecutionContext();
1521     if (!context) {
1522         ec = INVALID_ACCESS_ERR;
1523         return -1;
1524     }
1525     return DOMTimer::install(context, action, timeout, true);
1526 }
1527
1528 void DOMWindow::clearTimeout(int timeoutId)
1529 {
1530     ScriptExecutionContext* context = scriptExecutionContext();
1531     if (!context)
1532         return;
1533     DOMTimer::removeById(context, timeoutId);
1534 }
1535
1536 int DOMWindow::setInterval(PassOwnPtr<ScheduledAction> action, int timeout, ExceptionCode& ec)
1537 {
1538     ScriptExecutionContext* context = scriptExecutionContext();
1539     if (!context) {
1540         ec = INVALID_ACCESS_ERR;
1541         return -1;
1542     }
1543     return DOMTimer::install(context, action, timeout, false);
1544 }
1545
1546 void DOMWindow::clearInterval(int timeoutId)
1547 {
1548     ScriptExecutionContext* context = scriptExecutionContext();
1549     if (!context)
1550         return;
1551     DOMTimer::removeById(context, timeoutId);
1552 }
1553
1554 #if ENABLE(REQUEST_ANIMATION_FRAME)
1555 int DOMWindow::requestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback> callback)
1556 {
1557     callback->m_useLegacyTimeBase = false;
1558     if (Document* d = document())
1559         return d->requestAnimationFrame(callback);
1560     return 0;
1561 }
1562
1563 int DOMWindow::webkitRequestAnimationFrame(PassRefPtr<RequestAnimationFrameCallback> callback)
1564 {
1565     callback->m_useLegacyTimeBase = true;
1566     if (Document* d = document())
1567         return d->requestAnimationFrame(callback);
1568     return 0;
1569 }
1570
1571 void DOMWindow::cancelAnimationFrame(int id)
1572 {
1573     if (Document* d = document())
1574         d->cancelAnimationFrame(id);
1575 }
1576 #endif
1577
1578 #if ENABLE(CSS3_CONDITIONAL_RULES)
1579 DOMWindowCSS* DOMWindow::css()
1580 {
1581     if (!m_css)
1582         m_css = DOMWindowCSS::create();
1583     return m_css.get();
1584 }
1585 #endif
1586
1587 static void didAddStorageEventListener(DOMWindow* window)
1588 {
1589     // Creating these WebCore::Storage objects informs the system that we'd like to receive
1590     // notifications about storage events that might be triggered in other processes. Rather
1591     // than subscribe to these notifications explicitly, we subscribe to them implicitly to
1592     // simplify the work done by the system. 
1593     window->localStorage(IGNORE_EXCEPTION);
1594     window->sessionStorage(IGNORE_EXCEPTION);
1595 }
1596
1597 bool DOMWindow::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
1598 {
1599     if (!EventTarget::addEventListener(eventType, listener, useCapture))
1600         return false;
1601
1602     if (Document* document = this->document()) {
1603         document->addListenerTypeIfNeeded(eventType);
1604         if (eventType == eventNames().mousewheelEvent)
1605             document->didAddWheelEventHandler();
1606         else if (eventNames().isTouchEventType(eventType))
1607             document->didAddTouchEventHandler(document);
1608         else if (eventType == eventNames().storageEvent)
1609             didAddStorageEventListener(this);
1610     }
1611
1612     if (eventType == eventNames().unloadEvent)
1613         addUnloadEventListener(this);
1614     else if (eventType == eventNames().beforeunloadEvent && allowsBeforeUnloadListeners(this))
1615         addBeforeUnloadEventListener(this);
1616 #if ENABLE(DEVICE_ORIENTATION)
1617     else if (eventType == eventNames().devicemotionEvent && RuntimeEnabledFeatures::deviceMotionEnabled()) {
1618         if (DeviceMotionController* controller = DeviceMotionController::from(page()))
1619             controller->addDeviceEventListener(this);
1620     } else if (eventType == eventNames().deviceorientationEvent && RuntimeEnabledFeatures::deviceOrientationEnabled()) {
1621         if (DeviceOrientationController* controller = DeviceOrientationController::from(page()))
1622             controller->addDeviceEventListener(this);
1623     }
1624 #endif
1625
1626 #if ENABLE(PROXIMITY_EVENTS)
1627     else if (eventType == eventNames().webkitdeviceproximityEvent) {
1628         if (DeviceProximityController* controller = DeviceProximityController::from(page()))
1629             controller->addDeviceEventListener(this);
1630     }
1631 #endif
1632
1633     return true;
1634 }
1635
1636 bool DOMWindow::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
1637 {
1638     if (!EventTarget::removeEventListener(eventType, listener, useCapture))
1639         return false;
1640
1641     if (Document* document = this->document()) {
1642         if (eventType == eventNames().mousewheelEvent)
1643             document->didRemoveWheelEventHandler();
1644         else if (eventNames().isTouchEventType(eventType))
1645             document->didRemoveTouchEventHandler(document);
1646     }
1647
1648     if (eventType == eventNames().unloadEvent)
1649         removeUnloadEventListener(this);
1650     else if (eventType == eventNames().beforeunloadEvent && allowsBeforeUnloadListeners(this))
1651         removeBeforeUnloadEventListener(this);
1652 #if ENABLE(DEVICE_ORIENTATION)
1653     else if (eventType == eventNames().devicemotionEvent) {
1654         if (DeviceMotionController* controller = DeviceMotionController::from(page()))
1655             controller->removeDeviceEventListener(this);
1656     } else if (eventType == eventNames().deviceorientationEvent) {
1657         if (DeviceOrientationController* controller = DeviceOrientationController::from(page()))
1658             controller->removeDeviceEventListener(this);
1659     }
1660 #endif
1661
1662 #if ENABLE(PROXIMITY_EVENTS)
1663     else if (eventType == eventNames().webkitdeviceproximityEvent) {
1664         if (DeviceProximityController* controller = DeviceProximityController::from(page()))
1665             controller->removeDeviceEventListener(this);
1666     }
1667 #endif
1668
1669     return true;
1670 }
1671
1672 void DOMWindow::dispatchLoadEvent()
1673 {
1674     RefPtr<Event> loadEvent(Event::create(eventNames().loadEvent, false, false));
1675     if (m_frame && m_frame->loader()->documentLoader() && !m_frame->loader()->documentLoader()->timing()->loadEventStart()) {
1676         // The DocumentLoader (and thus its DocumentLoadTiming) might get destroyed while dispatching
1677         // the event, so protect it to prevent writing the end time into freed memory.
1678         RefPtr<DocumentLoader> documentLoader = m_frame->loader()->documentLoader();
1679         DocumentLoadTiming* timing = documentLoader->timing();
1680         timing->markLoadEventStart();
1681         dispatchEvent(loadEvent, document());
1682         timing->markLoadEventEnd();
1683     } else
1684         dispatchEvent(loadEvent, document());
1685
1686     // For load events, send a separate load event to the enclosing frame only.
1687     // This is a DOM extension and is independent of bubbling/capturing rules of
1688     // the DOM.
1689     Element* ownerElement = m_frame ? m_frame->ownerElement() : 0;
1690     if (ownerElement)
1691         ownerElement->dispatchEvent(Event::create(eventNames().loadEvent, false, false));
1692
1693     InspectorInstrumentation::loadEventFired(frame());
1694 }
1695
1696 bool DOMWindow::dispatchEvent(PassRefPtr<Event> prpEvent, PassRefPtr<EventTarget> prpTarget)
1697 {
1698     RefPtr<EventTarget> protect = this;
1699     RefPtr<Event> event = prpEvent;
1700
1701     event->setTarget(prpTarget ? prpTarget : this);
1702     event->setCurrentTarget(this);
1703     event->setEventPhase(Event::AT_TARGET);
1704
1705     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willDispatchEventOnWindow(frame(), *event, this);
1706
1707     bool result = fireEventListeners(event.get());
1708
1709     InspectorInstrumentation::didDispatchEventOnWindow(cookie);
1710
1711     return result;
1712 }
1713
1714 void DOMWindow::removeAllEventListeners()
1715 {
1716     EventTarget::removeAllEventListeners();
1717
1718 #if ENABLE(DEVICE_ORIENTATION)
1719     if (DeviceMotionController* controller = DeviceMotionController::from(page()))
1720         controller->removeAllDeviceEventListeners(this);
1721     if (DeviceOrientationController* controller = DeviceOrientationController::from(page()))
1722         controller->removeAllDeviceEventListeners(this);
1723 #endif
1724 #if ENABLE(TOUCH_EVENTS)
1725     if (Document* document = this->document())
1726         document->didRemoveEventTargetNode(document);
1727 #endif
1728
1729 #if ENABLE(PROXIMITY_EVENTS)
1730     if (DeviceProximityController* controller = DeviceProximityController::from(page()))
1731         controller->removeAllDeviceEventListeners(this);
1732 #endif
1733
1734     removeAllUnloadEventListeners(this);
1735     removeAllBeforeUnloadEventListeners(this);
1736 }
1737
1738 void DOMWindow::captureEvents()
1739 {
1740     // Not implemented.
1741 }
1742
1743 void DOMWindow::releaseEvents()
1744 {
1745     // Not implemented.
1746 }
1747
1748 void DOMWindow::finishedLoading()
1749 {
1750     if (m_shouldPrintWhenFinishedLoading) {
1751         m_shouldPrintWhenFinishedLoading = false;
1752         print();
1753     }
1754 }
1755
1756 EventTargetData* DOMWindow::eventTargetData()
1757 {
1758     return &m_eventTargetData;
1759 }
1760
1761 EventTargetData* DOMWindow::ensureEventTargetData()
1762 {
1763     return &m_eventTargetData;
1764 }
1765
1766 void DOMWindow::setLocation(const String& urlString, DOMWindow* activeWindow, DOMWindow* firstWindow, SetLocationLocking locking)
1767 {
1768     if (!isCurrentlyDisplayedInFrame())
1769         return;
1770
1771     Document* activeDocument = activeWindow->document();
1772     if (!activeDocument)
1773         return;
1774
1775     if (!activeDocument->canNavigate(m_frame))
1776         return;
1777
1778     Frame* firstFrame = firstWindow->frame();
1779     if (!firstFrame)
1780         return;
1781
1782     KURL completedURL = firstFrame->document()->completeURL(urlString);
1783     if (completedURL.isNull())
1784         return;
1785
1786     if (isInsecureScriptAccess(activeWindow, completedURL))
1787         return;
1788
1789     // We want a new history item if we are processing a user gesture.
1790     m_frame->navigationScheduler()->scheduleLocationChange(activeDocument->securityOrigin(),
1791         // FIXME: What if activeDocument()->frame() is 0?
1792         completedURL, activeDocument->frame()->loader()->outgoingReferrer(),
1793         locking != LockHistoryBasedOnGestureState || !ScriptController::processingUserGesture(),
1794         locking != LockHistoryBasedOnGestureState);
1795 }
1796
1797 void DOMWindow::printErrorMessage(const String& message)
1798 {
1799     if (message.isEmpty())
1800         return;
1801
1802     console()->addMessage(JSMessageSource, ErrorMessageLevel, message);
1803 }
1804
1805 String DOMWindow::crossDomainAccessErrorMessage(DOMWindow* activeWindow)
1806 {
1807     const KURL& activeWindowURL = activeWindow->document()->url();
1808     if (activeWindowURL.isNull())
1809         return String();
1810
1811     ASSERT(!activeWindow->document()->securityOrigin()->canAccess(document()->securityOrigin()));
1812
1813     // FIXME: This message, and other console messages, have extra newlines. Should remove them.
1814     String message = "Unsafe JavaScript attempt to access frame with URL " + document()->url().string() + " from frame with URL " + activeWindowURL.string() + ".";
1815
1816     // Sandbox errors.
1817     if (document()->isSandboxed(SandboxOrigin) || activeWindow->document()->isSandboxed(SandboxOrigin)) {
1818         if (document()->isSandboxed(SandboxOrigin) && activeWindow->document()->isSandboxed(SandboxOrigin))
1819             return "Sandbox access violation: " + message + " Both frames are sandboxed into unique origins.\n";
1820         if (document()->isSandboxed(SandboxOrigin))
1821             return "Sandbox access violation: " + message + " The frame being accessed is sandboxed into a unique origin.\n";
1822         return "Sandbox access violation: " + message + " The frame requesting access is sandboxed into a unique origin.\n";
1823     }
1824
1825     SecurityOrigin* activeOrigin = activeWindow->document()->securityOrigin();
1826     SecurityOrigin* targetOrigin = document()->securityOrigin();
1827     if (targetOrigin->protocol() != activeOrigin->protocol())
1828         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";
1829
1830     // 'document.domain' errors.
1831     if (targetOrigin->domainWasSetInDOM() && activeOrigin->domainWasSetInDOM())
1832         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";
1833     if (activeOrigin->domainWasSetInDOM())
1834         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";
1835     if (targetOrigin->domainWasSetInDOM())
1836         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";
1837
1838     // Default.
1839     return "Blocked a frame with origin \"" + activeOrigin->toString() + "\" from accessing a frame with origin \"" + targetOrigin->toString() + "\". Protocols, domains, and ports must match.";
1840 }
1841
1842 bool DOMWindow::isInsecureScriptAccess(DOMWindow* activeWindow, const String& urlString)
1843 {
1844     if (!protocolIsJavaScript(urlString))
1845         return false;
1846
1847     // If this DOMWindow isn't currently active in the Frame, then there's no
1848     // way we should allow the access.
1849     // FIXME: Remove this check if we're able to disconnect DOMWindow from
1850     // Frame on navigation: https://bugs.webkit.org/show_bug.cgi?id=62054
1851     if (isCurrentlyDisplayedInFrame()) {
1852         // FIXME: Is there some way to eliminate the need for a separate "activeWindow == this" check?
1853         if (activeWindow == this)
1854             return false;
1855
1856         // FIXME: The name canAccess seems to be a roundabout way to ask "can execute script".
1857         // Can we name the SecurityOrigin function better to make this more clear?
1858         if (activeWindow->document()->securityOrigin()->canAccess(document()->securityOrigin()))
1859             return false;
1860     }
1861
1862     printErrorMessage(crossDomainAccessErrorMessage(activeWindow));
1863     return true;
1864 }
1865
1866 Frame* DOMWindow::createWindow(const String& urlString, const AtomicString& frameName, const WindowFeatures& windowFeatures,
1867     DOMWindow* activeWindow, Frame* firstFrame, Frame* openerFrame, PrepareDialogFunction function, void* functionContext)
1868 {
1869     Frame* activeFrame = activeWindow->frame();
1870
1871     KURL completedURL = urlString.isEmpty() ? KURL(ParsedURLString, emptyString()) : firstFrame->document()->completeURL(urlString);
1872     if (!completedURL.isEmpty() && !completedURL.isValid()) {
1873         // Don't expose client code to invalid URLs.
1874         activeWindow->printErrorMessage("Unable to open a window with invalid URL '" + completedURL.string() + "'.\n");
1875         return 0;
1876     }
1877
1878     // For whatever reason, Firefox uses the first frame to determine the outgoingReferrer. We replicate that behavior here.
1879     String referrer = SecurityPolicy::generateReferrerHeader(firstFrame->document()->referrerPolicy(), completedURL, firstFrame->loader()->outgoingReferrer());
1880
1881     ResourceRequest request(completedURL, referrer);
1882     FrameLoader::addHTTPOriginIfNeeded(request, firstFrame->loader()->outgoingOrigin());
1883     FrameLoadRequest frameRequest(activeWindow->document()->securityOrigin(), request, frameName);
1884
1885     // We pass the opener frame for the lookupFrame in case the active frame is different from
1886     // the opener frame, and the name references a frame relative to the opener frame.
1887     bool created;
1888     Frame* newFrame = WebCore::createWindow(activeFrame, openerFrame, frameRequest, windowFeatures, created);
1889     if (!newFrame)
1890         return 0;
1891
1892     newFrame->loader()->setOpener(openerFrame);
1893     newFrame->page()->setOpenedByDOM();
1894
1895     if (newFrame->document()->domWindow()->isInsecureScriptAccess(activeWindow, completedURL))
1896         return newFrame;
1897
1898     if (function)
1899         function(newFrame->document()->domWindow(), functionContext);
1900
1901     if (created)
1902         newFrame->loader()->changeLocation(activeWindow->document()->securityOrigin(), completedURL, referrer, false, false);
1903     else if (!urlString.isEmpty()) {
1904         bool lockHistory = !ScriptController::processingUserGesture();
1905         newFrame->navigationScheduler()->scheduleLocationChange(activeWindow->document()->securityOrigin(), completedURL.string(), referrer, lockHistory, false);
1906     }
1907
1908     return newFrame;
1909 }
1910
1911 PassRefPtr<DOMWindow> DOMWindow::open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
1912     DOMWindow* activeWindow, DOMWindow* firstWindow)
1913 {
1914     if (!isCurrentlyDisplayedInFrame())
1915         return 0;
1916     Document* activeDocument = activeWindow->document();
1917     if (!activeDocument)
1918         return 0;
1919     Frame* firstFrame = firstWindow->frame();
1920     if (!firstFrame)
1921         return 0;
1922
1923     if (!firstWindow->allowPopUp()) {
1924         // Because FrameTree::find() returns true for empty strings, we must check for empty frame names.
1925         // Otherwise, illegitimate window.open() calls with no name will pass right through the popup blocker.
1926         if (frameName.isEmpty() || !m_frame->tree()->find(frameName))
1927             return 0;
1928     }
1929
1930     // Get the target frame for the special cases of _top and _parent.
1931     // In those cases, we schedule a location change right now and return early.
1932     Frame* targetFrame = 0;
1933     if (frameName == "_top")
1934         targetFrame = m_frame->tree()->top();
1935     else if (frameName == "_parent") {
1936         if (Frame* parent = m_frame->tree()->parent())
1937             targetFrame = parent;
1938         else
1939             targetFrame = m_frame;
1940     }
1941     if (targetFrame) {
1942         if (!activeDocument->canNavigate(targetFrame))
1943             return 0;
1944
1945         KURL completedURL = firstFrame->document()->completeURL(urlString);
1946
1947         if (targetFrame->document()->domWindow()->isInsecureScriptAccess(activeWindow, completedURL))
1948             return targetFrame->document()->domWindow();
1949
1950         if (urlString.isEmpty())
1951             return targetFrame->document()->domWindow();
1952
1953         // For whatever reason, Firefox uses the first window rather than the active window to
1954         // determine the outgoing referrer. We replicate that behavior here.
1955         bool lockHistory = !ScriptController::processingUserGesture();
1956         targetFrame->navigationScheduler()->scheduleLocationChange(
1957             activeDocument->securityOrigin(),
1958             completedURL,
1959             firstFrame->loader()->outgoingReferrer(),
1960             lockHistory,
1961             false);
1962         return targetFrame->document()->domWindow();
1963     }
1964
1965     WindowFeatures windowFeatures(windowFeaturesString);
1966     Frame* result = createWindow(urlString, frameName, windowFeatures, activeWindow, firstFrame, m_frame);
1967     return result ? result->document()->domWindow() : 0;
1968 }
1969
1970 void DOMWindow::showModalDialog(const String& urlString, const String& dialogFeaturesString,
1971     DOMWindow* activeWindow, DOMWindow* firstWindow, PrepareDialogFunction function, void* functionContext)
1972 {
1973     if (!isCurrentlyDisplayedInFrame())
1974         return;
1975     Frame* activeFrame = activeWindow->frame();
1976     if (!activeFrame)
1977         return;
1978     Frame* firstFrame = firstWindow->frame();
1979     if (!firstFrame)
1980         return;
1981
1982     if (!canShowModalDialogNow(m_frame) || !firstWindow->allowPopUp())
1983         return;
1984
1985     WindowFeatures windowFeatures(dialogFeaturesString, screenAvailableRect(m_frame->view()));
1986     Frame* dialogFrame = createWindow(urlString, emptyAtom, windowFeatures,
1987         activeWindow, firstFrame, m_frame, function, functionContext);
1988     if (!dialogFrame)
1989         return;
1990
1991     dialogFrame->page()->chrome()->runModal();
1992 }
1993
1994 } // namespace WebCore