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 "core/frame/LocalDOMWindow.h"
29
30#include "bindings/v8/ExceptionMessages.h"
31#include "bindings/v8/ExceptionState.h"
32#include "bindings/v8/ExceptionStatePlaceholder.h"
33#include "bindings/v8/ScriptCallStackFactory.h"
34#include "bindings/v8/ScriptController.h"
35#include "bindings/v8/SerializedScriptValue.h"
36#include "core/css/CSSComputedStyleDeclaration.h"
37#include "core/css/CSSRuleList.h"
38#include "core/css/DOMWindowCSS.h"
39#include "core/css/MediaQueryList.h"
40#include "core/css/MediaQueryMatcher.h"
41#include "core/css/StyleMedia.h"
42#include "core/css/resolver/StyleResolver.h"
43#include "core/dom/ContextFeatures.h"
44#include "core/dom/DOMImplementation.h"
45#include "core/dom/Document.h"
46#include "core/dom/Element.h"
47#include "core/dom/ExceptionCode.h"
48#include "core/dom/ExecutionContext.h"
49#include "core/dom/NoEventDispatchAssertion.h"
50#include "core/dom/RequestAnimationFrameCallback.h"
51#include "core/editing/Editor.h"
52#include "core/events/DOMWindowEventQueue.h"
53#include "core/events/EventListener.h"
54#include "core/events/HashChangeEvent.h"
55#include "core/events/MessageEvent.h"
56#include "core/events/PageTransitionEvent.h"
57#include "core/events/PopStateEvent.h"
58#include "core/frame/BarProp.h"
59#include "core/frame/Console.h"
60#include "core/frame/DOMPoint.h"
61#include "core/frame/DOMWindowLifecycleNotifier.h"
62#include "core/frame/EventHandlerRegistry.h"
63#include "core/frame/FrameConsole.h"
64#include "core/frame/FrameHost.h"
65#include "core/frame/FrameView.h"
66#include "core/frame/History.h"
67#include "core/frame/LocalFrame.h"
68#include "core/frame/Location.h"
69#include "core/frame/Navigator.h"
70#include "core/frame/Screen.h"
71#include "core/frame/Settings.h"
72#include "core/html/HTMLFrameOwnerElement.h"
73#include "core/inspector/InspectorInstrumentation.h"
74#include "core/inspector/InspectorTraceEvents.h"
75#include "core/inspector/ScriptCallStack.h"
76#include "core/loader/DocumentLoader.h"
77#include "core/loader/FrameLoadRequest.h"
78#include "core/loader/FrameLoader.h"
79#include "core/loader/FrameLoaderClient.h"
80#include "core/loader/MixedContentChecker.h"
81#include "core/loader/SinkDocument.h"
82#include "core/loader/appcache/ApplicationCache.h"
83#include "core/page/BackForwardClient.h"
84#include "core/page/Chrome.h"
85#include "core/page/ChromeClient.h"
86#include "core/page/CreateWindow.h"
87#include "core/page/EventHandler.h"
88#include "core/page/FrameTree.h"
89#include "core/page/Page.h"
90#include "core/page/WindowFeatures.h"
91#include "core/page/WindowFocusAllowedIndicator.h"
92#include "core/page/scrolling/ScrollingCoordinator.h"
93#include "core/storage/Storage.h"
94#include "core/storage/StorageArea.h"
95#include "core/storage/StorageNamespace.h"
96#include "core/timing/Performance.h"
97#include "platform/PlatformScreen.h"
98#include "platform/RuntimeEnabledFeatures.h"
99#include "platform/UserGestureIndicator.h"
100#include "platform/geometry/FloatRect.h"
101#include "platform/graphics/media/MediaPlayer.h"
102#include "platform/weborigin/KURL.h"
103#include "platform/weborigin/SecurityOrigin.h"
104#include "platform/weborigin/SecurityPolicy.h"
105#include "public/platform/Platform.h"
106#include "wtf/MainThread.h"
107#include "wtf/MathExtras.h"
108#include "wtf/text/WTFString.h"
109#include <algorithm>
110
111using std::min;
112using std::max;
113
114namespace WebCore {
115
116class PostMessageTimer FINAL : public SuspendableTimer {
117public:
118    PostMessageTimer(LocalDOMWindow& window, PassRefPtr<SerializedScriptValue> message, const String& sourceOrigin, PassRefPtrWillBeRawPtr<LocalDOMWindow> source, PassOwnPtr<MessagePortChannelArray> channels, SecurityOrigin* targetOrigin, PassRefPtrWillBeRawPtr<ScriptCallStack> stackTrace, UserGestureToken* userGestureToken)
119        : SuspendableTimer(window.document())
120        , m_window(&window)
121        , m_message(message)
122        , m_origin(sourceOrigin)
123        , m_source(source)
124        , m_channels(channels)
125        , m_targetOrigin(targetOrigin)
126        , m_stackTrace(stackTrace)
127        , m_userGestureToken(userGestureToken)
128    {
129    }
130
131    PassRefPtrWillBeRawPtr<MessageEvent> event()
132    {
133        return MessageEvent::create(m_channels.release(), m_message, m_origin, String(), m_source.get());
134
135    }
136    SecurityOrigin* targetOrigin() const { return m_targetOrigin.get(); }
137    ScriptCallStack* stackTrace() const { return m_stackTrace.get(); }
138    UserGestureToken* userGestureToken() const { return m_userGestureToken.get(); }
139
140private:
141    virtual void fired() OVERRIDE
142    {
143        m_window->postMessageTimerFired(this);
144        // This object is deleted now.
145    }
146
147    // FIXME: Oilpan: This raw pointer is safe because the PostMessageTimer is
148    // owned by the LocalDOMWindow. Ideally PostMessageTimer should be moved to
149    // the heap and use Member<LocalDOMWindow>.
150    LocalDOMWindow* m_window;
151    RefPtr<SerializedScriptValue> m_message;
152    String m_origin;
153    RefPtrWillBePersistent<LocalDOMWindow> m_source;
154    OwnPtr<MessagePortChannelArray> m_channels;
155    RefPtr<SecurityOrigin> m_targetOrigin;
156    RefPtrWillBePersistent<ScriptCallStack> m_stackTrace;
157    RefPtr<UserGestureToken> m_userGestureToken;
158};
159
160static void disableSuddenTermination()
161{
162    blink::Platform::current()->suddenTerminationChanged(false);
163}
164
165static void enableSuddenTermination()
166{
167    blink::Platform::current()->suddenTerminationChanged(true);
168}
169
170typedef HashCountedSet<LocalDOMWindow*> DOMWindowSet;
171
172static DOMWindowSet& windowsWithUnloadEventListeners()
173{
174    DEFINE_STATIC_LOCAL(DOMWindowSet, windowsWithUnloadEventListeners, ());
175    return windowsWithUnloadEventListeners;
176}
177
178static DOMWindowSet& windowsWithBeforeUnloadEventListeners()
179{
180    DEFINE_STATIC_LOCAL(DOMWindowSet, windowsWithBeforeUnloadEventListeners, ());
181    return windowsWithBeforeUnloadEventListeners;
182}
183
184static void addUnloadEventListener(LocalDOMWindow* domWindow)
185{
186    DOMWindowSet& set = windowsWithUnloadEventListeners();
187    if (set.isEmpty())
188        disableSuddenTermination();
189    set.add(domWindow);
190}
191
192static void removeUnloadEventListener(LocalDOMWindow* domWindow)
193{
194    DOMWindowSet& set = windowsWithUnloadEventListeners();
195    DOMWindowSet::iterator it = set.find(domWindow);
196    if (it == set.end())
197        return;
198    set.remove(it);
199    if (set.isEmpty())
200        enableSuddenTermination();
201}
202
203static void removeAllUnloadEventListeners(LocalDOMWindow* domWindow)
204{
205    DOMWindowSet& set = windowsWithUnloadEventListeners();
206    DOMWindowSet::iterator it = set.find(domWindow);
207    if (it == set.end())
208        return;
209    set.removeAll(it);
210    if (set.isEmpty())
211        enableSuddenTermination();
212}
213
214static void addBeforeUnloadEventListener(LocalDOMWindow* domWindow)
215{
216    DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();
217    if (set.isEmpty())
218        disableSuddenTermination();
219    set.add(domWindow);
220}
221
222static void removeBeforeUnloadEventListener(LocalDOMWindow* domWindow)
223{
224    DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();
225    DOMWindowSet::iterator it = set.find(domWindow);
226    if (it == set.end())
227        return;
228    set.remove(it);
229    if (set.isEmpty())
230        enableSuddenTermination();
231}
232
233static void removeAllBeforeUnloadEventListeners(LocalDOMWindow* domWindow)
234{
235    DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();
236    DOMWindowSet::iterator it = set.find(domWindow);
237    if (it == set.end())
238        return;
239    set.removeAll(it);
240    if (set.isEmpty())
241        enableSuddenTermination();
242}
243
244static bool allowsBeforeUnloadListeners(LocalDOMWindow* window)
245{
246    ASSERT_ARG(window, window);
247    LocalFrame* frame = window->frame();
248    if (!frame)
249        return false;
250    return frame->isMainFrame();
251}
252
253unsigned LocalDOMWindow::pendingUnloadEventListeners() const
254{
255    return windowsWithUnloadEventListeners().count(const_cast<LocalDOMWindow*>(this));
256}
257
258// This function:
259// 1) Validates the pending changes are not changing any value to NaN; in that case keep original value.
260// 2) Constrains the window rect to the minimum window size and no bigger than the float rect's dimensions.
261// 3) Constrains the window rect to within the top and left boundaries of the available screen rect.
262// 4) Constrains the window rect to within the bottom and right boundaries of the available screen rect.
263// 5) Translate the window rect coordinates to be within the coordinate space of the screen.
264FloatRect LocalDOMWindow::adjustWindowRect(LocalFrame& frame, const FloatRect& pendingChanges)
265{
266    FrameHost* host = frame.host();
267    ASSERT(host);
268
269    FloatRect screen = screenAvailableRect(frame.view());
270    FloatRect window = host->chrome().windowRect();
271
272    // Make sure we're in a valid state before adjusting dimensions.
273    ASSERT(std::isfinite(screen.x()));
274    ASSERT(std::isfinite(screen.y()));
275    ASSERT(std::isfinite(screen.width()));
276    ASSERT(std::isfinite(screen.height()));
277    ASSERT(std::isfinite(window.x()));
278    ASSERT(std::isfinite(window.y()));
279    ASSERT(std::isfinite(window.width()));
280    ASSERT(std::isfinite(window.height()));
281
282    // Update window values if new requested values are not NaN.
283    if (!std::isnan(pendingChanges.x()))
284        window.setX(pendingChanges.x());
285    if (!std::isnan(pendingChanges.y()))
286        window.setY(pendingChanges.y());
287    if (!std::isnan(pendingChanges.width()))
288        window.setWidth(pendingChanges.width());
289    if (!std::isnan(pendingChanges.height()))
290        window.setHeight(pendingChanges.height());
291
292    FloatSize minimumSize = host->chrome().client().minimumWindowSize();
293    // Let size 0 pass through, since that indicates default size, not minimum size.
294    if (window.width())
295        window.setWidth(min(max(minimumSize.width(), window.width()), screen.width()));
296    if (window.height())
297        window.setHeight(min(max(minimumSize.height(), window.height()), screen.height()));
298
299    // Constrain the window position within the valid screen area.
300    window.setX(max(screen.x(), min(window.x(), screen.maxX() - window.width())));
301    window.setY(max(screen.y(), min(window.y(), screen.maxY() - window.height())));
302
303    return window;
304}
305
306bool LocalDOMWindow::allowPopUp(LocalFrame& firstFrame)
307{
308    if (UserGestureIndicator::processingUserGesture())
309        return true;
310
311    Settings* settings = firstFrame.settings();
312    return settings && settings->javaScriptCanOpenWindowsAutomatically();
313}
314
315bool LocalDOMWindow::allowPopUp()
316{
317    return m_frame && allowPopUp(*m_frame);
318}
319
320bool LocalDOMWindow::canShowModalDialogNow(const LocalFrame* frame)
321{
322    if (!frame)
323        return false;
324    FrameHost* host = frame->host();
325    if (!host)
326        return false;
327    return host->chrome().canRunModalNow();
328}
329
330LocalDOMWindow::LocalDOMWindow(LocalFrame& frame)
331    : FrameDestructionObserver(&frame)
332    , m_shouldPrintWhenFinishedLoading(false)
333#if ASSERT_ENABLED
334    , m_hasBeenReset(false)
335#endif
336{
337    ScriptWrappable::init(this);
338}
339
340void LocalDOMWindow::clearDocument()
341{
342    if (!m_document)
343        return;
344
345    if (m_document->isActive()) {
346        // FIXME: We don't call willRemove here. Why is that OK?
347        // This detach() call is also mostly redundant. Most of the calls to
348        // this function come via DocumentLoader::createWriterFor, which
349        // always detaches the previous Document first. Only XSLTProcessor
350        // depends on this detach() call, so it seems like there's some room
351        // for cleanup.
352        m_document->detach();
353    }
354
355    // FIXME: This should be part of ActiveDOMObject shutdown
356    clearEventQueue();
357
358    m_document->clearDOMWindow();
359    m_document = nullptr;
360}
361
362void LocalDOMWindow::clearEventQueue()
363{
364    if (!m_eventQueue)
365        return;
366    m_eventQueue->close();
367    m_eventQueue.clear();
368}
369
370void LocalDOMWindow::acceptLanguagesChanged()
371{
372    if (m_navigator)
373        m_navigator->setLanguagesChanged();
374
375    dispatchEvent(Event::create(EventTypeNames::languagechange));
376}
377
378PassRefPtrWillBeRawPtr<Document> LocalDOMWindow::createDocument(const String& mimeType, const DocumentInit& init, bool forceXHTML)
379{
380    RefPtrWillBeRawPtr<Document> document = nullptr;
381    if (forceXHTML) {
382        // This is a hack for XSLTProcessor. See XSLTProcessor::createDocumentFromSource().
383        document = Document::create(init);
384    } else {
385        document = DOMImplementation::createDocument(mimeType, init, init.frame() ? init.frame()->inViewSourceMode() : false);
386        if (document->isPluginDocument() && document->isSandboxed(SandboxPlugins))
387            document = SinkDocument::create(init);
388    }
389
390    return document.release();
391}
392
393PassRefPtrWillBeRawPtr<Document> LocalDOMWindow::installNewDocument(const String& mimeType, const DocumentInit& init, bool forceXHTML)
394{
395    ASSERT(init.frame() == m_frame);
396
397    clearDocument();
398
399    m_document = createDocument(mimeType, init, forceXHTML);
400    m_eventQueue = DOMWindowEventQueue::create(m_document.get());
401    m_document->attach();
402
403    if (!m_frame) {
404        // FIXME: Oilpan: Remove .get() when m_document becomes Member<>.
405        return m_document.get();
406    }
407
408    m_frame->script().updateDocument();
409    m_document->updateViewportDescription();
410
411    if (m_frame->page() && m_frame->view()) {
412        if (ScrollingCoordinator* scrollingCoordinator = m_frame->page()->scrollingCoordinator()) {
413            scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_frame->view(), HorizontalScrollbar);
414            scrollingCoordinator->scrollableAreaScrollbarLayerDidChange(m_frame->view(), VerticalScrollbar);
415            scrollingCoordinator->scrollableAreaScrollLayerDidChange(m_frame->view());
416        }
417    }
418
419    m_frame->selection().updateSecureKeyboardEntryIfActive();
420
421    if (m_frame->isMainFrame()) {
422        if (m_document->hasTouchEventHandlers())
423            m_frame->host()->chrome().client().needTouchEvents(true);
424    }
425
426    // FIXME: Oilpan: Remove .get() when m_document becomes Member<>.
427    return m_document.get();
428}
429
430EventQueue* LocalDOMWindow::eventQueue() const
431{
432    return m_eventQueue.get();
433}
434
435void LocalDOMWindow::enqueueWindowEvent(PassRefPtrWillBeRawPtr<Event> event)
436{
437    if (!m_eventQueue)
438        return;
439    event->setTarget(this);
440    m_eventQueue->enqueueEvent(event);
441}
442
443void LocalDOMWindow::enqueueDocumentEvent(PassRefPtrWillBeRawPtr<Event> event)
444{
445    if (!m_eventQueue)
446        return;
447    event->setTarget(m_document.get());
448    m_eventQueue->enqueueEvent(event);
449}
450
451void LocalDOMWindow::dispatchWindowLoadEvent()
452{
453    ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
454    dispatchLoadEvent();
455}
456
457void LocalDOMWindow::documentWasClosed()
458{
459    dispatchWindowLoadEvent();
460    enqueuePageshowEvent(PageshowEventNotPersisted);
461    if (m_pendingStateObject)
462        enqueuePopstateEvent(m_pendingStateObject.release());
463}
464
465void LocalDOMWindow::enqueuePageshowEvent(PageshowEventPersistence persisted)
466{
467    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36334 Pageshow event needs to fire asynchronously.
468    // As per spec pageshow must be triggered asynchronously.
469    // However to be compatible with other browsers blink fires pageshow synchronously.
470    dispatchEvent(PageTransitionEvent::create(EventTypeNames::pageshow, persisted), m_document.get());
471}
472
473void LocalDOMWindow::enqueueHashchangeEvent(const String& oldURL, const String& newURL)
474{
475    enqueueWindowEvent(HashChangeEvent::create(oldURL, newURL));
476}
477
478void LocalDOMWindow::enqueuePopstateEvent(PassRefPtr<SerializedScriptValue> stateObject)
479{
480    if (!ContextFeatures::pushStateEnabled(document()))
481        return;
482
483    // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36202 Popstate event needs to fire asynchronously
484    dispatchEvent(PopStateEvent::create(stateObject, &history()));
485}
486
487void LocalDOMWindow::statePopped(PassRefPtr<SerializedScriptValue> stateObject)
488{
489    if (!frame())
490        return;
491
492    // Per step 11 of section 6.5.9 (history traversal) of the HTML5 spec, we
493    // defer firing of popstate until we're in the complete state.
494    if (document()->isLoadCompleted())
495        enqueuePopstateEvent(stateObject);
496    else
497        m_pendingStateObject = stateObject;
498}
499
500LocalDOMWindow::~LocalDOMWindow()
501{
502    ASSERT(m_hasBeenReset);
503    reset();
504
505#if ENABLE(OILPAN)
506    // Oilpan: the frame host and document objects are
507    // also garbage collected; cannot notify these
508    // when removing event listeners.
509    removeAllEventListenersInternal(DoNotBroadcastListenerRemoval);
510
511    // Cleared when detaching document.
512    ASSERT(!m_eventQueue);
513#else
514    removeAllEventListenersInternal(DoBroadcastListenerRemoval);
515
516    ASSERT(m_document->isStopped());
517    clearDocument();
518#endif
519}
520
521const AtomicString& LocalDOMWindow::interfaceName() const
522{
523    return EventTargetNames::LocalDOMWindow;
524}
525
526ExecutionContext* LocalDOMWindow::executionContext() const
527{
528    return m_document.get();
529}
530
531LocalDOMWindow* LocalDOMWindow::toDOMWindow()
532{
533    return this;
534}
535
536PassRefPtrWillBeRawPtr<MediaQueryList> LocalDOMWindow::matchMedia(const String& media)
537{
538    return document() ? document()->mediaQueryMatcher().matchMedia(media) : nullptr;
539}
540
541Page* LocalDOMWindow::page()
542{
543    return frame() ? frame()->page() : 0;
544}
545
546void LocalDOMWindow::frameDestroyed()
547{
548    FrameDestructionObserver::frameDestroyed();
549    reset();
550}
551
552void LocalDOMWindow::willDetachFrameHost()
553{
554    m_frame->host()->eventHandlerRegistry().didRemoveAllEventHandlers(*this);
555    InspectorInstrumentation::frameWindowDiscarded(m_frame, this);
556}
557
558void LocalDOMWindow::willDestroyDocumentInFrame()
559{
560    // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
561    // unregister themselves from the LocalDOMWindow as a result of the call to willDestroyGlobalObjectInFrame.
562    Vector<DOMWindowProperty*> properties;
563    copyToVector(m_properties, properties);
564    for (size_t i = 0; i < properties.size(); ++i)
565        properties[i]->willDestroyGlobalObjectInFrame();
566}
567
568void LocalDOMWindow::willDetachDocumentFromFrame()
569{
570    // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
571    // unregister themselves from the LocalDOMWindow as a result of the call to willDetachGlobalObjectFromFrame.
572    Vector<DOMWindowProperty*> properties;
573    copyToVector(m_properties, properties);
574    for (size_t i = 0; i < properties.size(); ++i)
575        properties[i]->willDetachGlobalObjectFromFrame();
576}
577
578void LocalDOMWindow::registerProperty(DOMWindowProperty* property)
579{
580    m_properties.add(property);
581}
582
583void LocalDOMWindow::unregisterProperty(DOMWindowProperty* property)
584{
585    m_properties.remove(property);
586}
587
588void LocalDOMWindow::reset()
589{
590    willDestroyDocumentInFrame();
591    resetDOMWindowProperties();
592}
593
594void LocalDOMWindow::resetDOMWindowProperties()
595{
596    m_properties.clear();
597
598    m_screen = nullptr;
599    m_history = nullptr;
600    m_locationbar = nullptr;
601    m_menubar = nullptr;
602    m_personalbar = nullptr;
603    m_scrollbars = nullptr;
604    m_statusbar = nullptr;
605    m_toolbar = nullptr;
606    m_console = nullptr;
607    m_navigator = nullptr;
608    m_performance = nullptr;
609    m_location = nullptr;
610    m_media = nullptr;
611    m_sessionStorage = nullptr;
612    m_localStorage = nullptr;
613    m_applicationCache = nullptr;
614#if ASSERT_ENABLED
615    m_hasBeenReset = true;
616#endif
617}
618
619bool LocalDOMWindow::isCurrentlyDisplayedInFrame() const
620{
621    return m_frame && m_frame->domWindow() == this && m_frame->host();
622}
623
624int LocalDOMWindow::orientation() const
625{
626    ASSERT(RuntimeEnabledFeatures::orientationEventEnabled());
627
628    if (!m_frame)
629        return 0;
630
631    int orientation = screenOrientationAngle(m_frame->view());
632    // For backward compatibility, we want to return a value in the range of
633    // [-90; 180] instead of [0; 360[ because window.orientation used to behave
634    // like that in WebKit (this is a WebKit proprietary API).
635    if (orientation == 270)
636        return -90;
637    return orientation;
638}
639
640Screen& LocalDOMWindow::screen() const
641{
642    if (!m_screen)
643        m_screen = Screen::create(m_frame);
644    return *m_screen;
645}
646
647History& LocalDOMWindow::history() const
648{
649    if (!m_history)
650        m_history = History::create(m_frame);
651    return *m_history;
652}
653
654BarProp& LocalDOMWindow::locationbar() const
655{
656    if (!m_locationbar)
657        m_locationbar = BarProp::create(m_frame, BarProp::Locationbar);
658    return *m_locationbar;
659}
660
661BarProp& LocalDOMWindow::menubar() const
662{
663    if (!m_menubar)
664        m_menubar = BarProp::create(m_frame, BarProp::Menubar);
665    return *m_menubar;
666}
667
668BarProp& LocalDOMWindow::personalbar() const
669{
670    if (!m_personalbar)
671        m_personalbar = BarProp::create(m_frame, BarProp::Personalbar);
672    return *m_personalbar;
673}
674
675BarProp& LocalDOMWindow::scrollbars() const
676{
677    if (!m_scrollbars)
678        m_scrollbars = BarProp::create(m_frame, BarProp::Scrollbars);
679    return *m_scrollbars;
680}
681
682BarProp& LocalDOMWindow::statusbar() const
683{
684    if (!m_statusbar)
685        m_statusbar = BarProp::create(m_frame, BarProp::Statusbar);
686    return *m_statusbar;
687}
688
689BarProp& LocalDOMWindow::toolbar() const
690{
691    if (!m_toolbar)
692        m_toolbar = BarProp::create(m_frame, BarProp::Toolbar);
693    return *m_toolbar;
694}
695
696Console& LocalDOMWindow::console() const
697{
698    if (!m_console)
699        m_console = Console::create(m_frame);
700    return *m_console;
701}
702
703FrameConsole* LocalDOMWindow::frameConsole() const
704{
705    if (!isCurrentlyDisplayedInFrame())
706        return 0;
707    return &m_frame->console();
708}
709
710ApplicationCache* LocalDOMWindow::applicationCache() const
711{
712    if (!isCurrentlyDisplayedInFrame())
713        return 0;
714    if (!m_applicationCache)
715        m_applicationCache = ApplicationCache::create(m_frame);
716    return m_applicationCache.get();
717}
718
719Navigator& LocalDOMWindow::navigator() const
720{
721    if (!m_navigator)
722        m_navigator = Navigator::create(m_frame);
723    return *m_navigator;
724}
725
726Performance& LocalDOMWindow::performance() const
727{
728    if (!m_performance)
729        m_performance = Performance::create(m_frame);
730    return *m_performance;
731}
732
733Location& LocalDOMWindow::location() const
734{
735    if (!m_location)
736        m_location = Location::create(m_frame);
737    return *m_location;
738}
739
740Storage* LocalDOMWindow::sessionStorage(ExceptionState& exceptionState) const
741{
742    if (!isCurrentlyDisplayedInFrame())
743        return 0;
744
745    Document* document = this->document();
746    if (!document)
747        return 0;
748
749    String accessDeniedMessage = "Access is denied for this document.";
750    if (!document->securityOrigin()->canAccessLocalStorage()) {
751        if (document->isSandboxed(SandboxOrigin))
752            exceptionState.throwSecurityError("The document is sandboxed and lacks the 'allow-same-origin' flag.");
753        else if (document->url().protocolIs("data"))
754            exceptionState.throwSecurityError("Storage is disabled inside 'data:' URLs.");
755        else
756            exceptionState.throwSecurityError(accessDeniedMessage);
757        return 0;
758    }
759
760    if (m_sessionStorage) {
761        if (!m_sessionStorage->area()->canAccessStorage(m_frame)) {
762            exceptionState.throwSecurityError(accessDeniedMessage);
763            return 0;
764        }
765        return m_sessionStorage.get();
766    }
767
768    Page* page = document->page();
769    if (!page)
770        return 0;
771
772    OwnPtrWillBeRawPtr<StorageArea> storageArea = page->sessionStorage()->storageArea(document->securityOrigin());
773    if (!storageArea->canAccessStorage(m_frame)) {
774        exceptionState.throwSecurityError(accessDeniedMessage);
775        return 0;
776    }
777
778    m_sessionStorage = Storage::create(m_frame, storageArea.release());
779    return m_sessionStorage.get();
780}
781
782Storage* LocalDOMWindow::localStorage(ExceptionState& exceptionState) const
783{
784    if (!isCurrentlyDisplayedInFrame())
785        return 0;
786
787    Document* document = this->document();
788    if (!document)
789        return 0;
790
791    String accessDeniedMessage = "Access is denied for this document.";
792    if (!document->securityOrigin()->canAccessLocalStorage()) {
793        if (document->isSandboxed(SandboxOrigin))
794            exceptionState.throwSecurityError("The document is sandboxed and lacks the 'allow-same-origin' flag.");
795        else if (document->url().protocolIs("data"))
796            exceptionState.throwSecurityError("Storage is disabled inside 'data:' URLs.");
797        else
798            exceptionState.throwSecurityError(accessDeniedMessage);
799        return 0;
800    }
801
802    if (m_localStorage) {
803        if (!m_localStorage->area()->canAccessStorage(m_frame)) {
804            exceptionState.throwSecurityError(accessDeniedMessage);
805            return 0;
806        }
807        return m_localStorage.get();
808    }
809
810    // FIXME: Seems this check should be much higher?
811    FrameHost* host = document->frameHost();
812    if (!host || !host->settings().localStorageEnabled())
813        return 0;
814
815    OwnPtrWillBeRawPtr<StorageArea> storageArea = StorageNamespace::localStorageArea(document->securityOrigin());
816    if (!storageArea->canAccessStorage(m_frame)) {
817        exceptionState.throwSecurityError(accessDeniedMessage);
818        return 0;
819    }
820
821    m_localStorage = Storage::create(m_frame, storageArea.release());
822    return m_localStorage.get();
823}
824
825void LocalDOMWindow::postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, const String& targetOrigin, LocalDOMWindow* source, ExceptionState& exceptionState)
826{
827    if (!isCurrentlyDisplayedInFrame())
828        return;
829
830    Document* sourceDocument = source->document();
831
832    // Compute the target origin.  We need to do this synchronously in order
833    // to generate the SyntaxError exception correctly.
834    RefPtr<SecurityOrigin> target;
835    if (targetOrigin == "/") {
836        if (!sourceDocument)
837            return;
838        target = sourceDocument->securityOrigin();
839    } else if (targetOrigin != "*") {
840        target = SecurityOrigin::createFromString(targetOrigin);
841        // It doesn't make sense target a postMessage at a unique origin
842        // because there's no way to represent a unique origin in a string.
843        if (target->isUnique()) {
844            exceptionState.throwDOMException(SyntaxError, "Invalid target origin '" + targetOrigin + "' in a call to 'postMessage'.");
845            return;
846        }
847    }
848
849    OwnPtr<MessagePortChannelArray> channels = MessagePort::disentanglePorts(ports, exceptionState);
850    if (exceptionState.hadException())
851        return;
852
853    // Capture the source of the message.  We need to do this synchronously
854    // in order to capture the source of the message correctly.
855    if (!sourceDocument)
856        return;
857    String sourceOrigin = sourceDocument->securityOrigin()->toString();
858
859    if (MixedContentChecker::isMixedContent(sourceDocument->securityOrigin(), document()->url()))
860        UseCounter::count(document(), UseCounter::PostMessageFromSecureToInsecure);
861    else if (MixedContentChecker::isMixedContent(document()->securityOrigin(), sourceDocument->url()))
862        UseCounter::count(document(), UseCounter::PostMessageFromInsecureToSecure);
863
864    // Capture stack trace only when inspector front-end is loaded as it may be time consuming.
865    RefPtrWillBeRawPtr<ScriptCallStack> stackTrace = nullptr;
866    if (InspectorInstrumentation::consoleAgentEnabled(sourceDocument))
867        stackTrace = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
868
869    // Schedule the message.
870    OwnPtr<PostMessageTimer> timer = adoptPtr(new PostMessageTimer(*this, message, sourceOrigin, source, channels.release(), target.get(), stackTrace.release(), UserGestureIndicator::currentToken()));
871    timer->startOneShot(0, FROM_HERE);
872    timer->suspendIfNeeded();
873    m_postMessageTimers.add(timer.release());
874}
875
876void LocalDOMWindow::postMessageTimerFired(PostMessageTimer* timer)
877{
878    if (!isCurrentlyDisplayedInFrame()) {
879        m_postMessageTimers.remove(timer);
880        return;
881    }
882
883    RefPtrWillBeRawPtr<MessageEvent> event = timer->event();
884
885    // Give the embedder a chance to intercept this postMessage because this
886    // LocalDOMWindow might be a proxy for another in browsers that support
887    // postMessage calls across WebKit instances.
888    if (m_frame->loader().client()->willCheckAndDispatchMessageEvent(timer->targetOrigin(), event.get())) {
889        m_postMessageTimers.remove(timer);
890        return;
891    }
892
893    UserGestureIndicator gestureIndicator(timer->userGestureToken());
894
895    event->entangleMessagePorts(document());
896    dispatchMessageEventWithOriginCheck(timer->targetOrigin(), event, timer->stackTrace());
897    m_postMessageTimers.remove(timer);
898}
899
900void LocalDOMWindow::dispatchMessageEventWithOriginCheck(SecurityOrigin* intendedTargetOrigin, PassRefPtrWillBeRawPtr<Event> event, PassRefPtrWillBeRawPtr<ScriptCallStack> stackTrace)
901{
902    if (intendedTargetOrigin) {
903        // Check target origin now since the target document may have changed since the timer was scheduled.
904        if (!intendedTargetOrigin->isSameSchemeHostPort(document()->securityOrigin())) {
905            String message = ExceptionMessages::failedToExecute("postMessage", "DOMWindow", "The target origin provided ('" + intendedTargetOrigin->toString() + "') does not match the recipient window's origin ('" + document()->securityOrigin()->toString() + "').");
906            frameConsole()->addMessage(SecurityMessageSource, ErrorMessageLevel, message, stackTrace);
907            return;
908        }
909    }
910
911    dispatchEvent(event);
912}
913
914DOMSelection* LocalDOMWindow::getSelection()
915{
916    if (!isCurrentlyDisplayedInFrame() || !m_frame)
917        return 0;
918
919    return m_frame->document()->getSelection();
920}
921
922Element* LocalDOMWindow::frameElement() const
923{
924    if (!m_frame)
925        return 0;
926
927    // The bindings security check should ensure we're same origin...
928    ASSERT(!m_frame->owner() || m_frame->owner()->isLocal());
929    return m_frame->deprecatedLocalOwner();
930}
931
932void LocalDOMWindow::focus(ExecutionContext* context)
933{
934    if (!m_frame)
935        return;
936
937    FrameHost* host = m_frame->host();
938    if (!host)
939        return;
940
941    bool allowFocus = WindowFocusAllowedIndicator::windowFocusAllowed();
942    if (context) {
943        ASSERT(isMainThread());
944        Document* activeDocument = toDocument(context);
945        if (opener() && opener() != this && activeDocument->domWindow() == opener())
946            allowFocus = true;
947    }
948
949    // If we're a top level window, bring the window to the front.
950    if (m_frame->isMainFrame() && allowFocus)
951        host->chrome().focus();
952
953    if (!m_frame)
954        return;
955
956    m_frame->eventHandler().focusDocumentView();
957}
958
959void LocalDOMWindow::blur()
960{
961}
962
963void LocalDOMWindow::close(ExecutionContext* context)
964{
965    if (!m_frame || !m_frame->isMainFrame())
966        return;
967
968    Page* page = m_frame->page();
969    if (!page)
970        return;
971
972    if (context) {
973        ASSERT(isMainThread());
974        Document* activeDocument = toDocument(context);
975        if (!activeDocument)
976            return;
977
978        if (!activeDocument->canNavigate(*m_frame))
979            return;
980    }
981
982    Settings* settings = m_frame->settings();
983    bool allowScriptsToCloseWindows = settings && settings->allowScriptsToCloseWindows();
984
985    if (!(page->openedByDOM() || page->backForward().backForwardListCount() <= 1 || allowScriptsToCloseWindows)) {
986        frameConsole()->addMessage(JSMessageSource, WarningMessageLevel, "Scripts may close only the windows that were opened by it.");
987        return;
988    }
989
990    if (!m_frame->loader().shouldClose())
991        return;
992
993    page->chrome().closeWindowSoon();
994}
995
996void LocalDOMWindow::print()
997{
998    if (!m_frame)
999        return;
1000
1001    FrameHost* host = m_frame->host();
1002    if (!host)
1003        return;
1004
1005    if (m_frame->loader().state() != FrameStateComplete) {
1006        m_shouldPrintWhenFinishedLoading = true;
1007        return;
1008    }
1009    m_shouldPrintWhenFinishedLoading = false;
1010    host->chrome().print(m_frame);
1011}
1012
1013void LocalDOMWindow::stop()
1014{
1015    if (!m_frame)
1016        return;
1017    m_frame->loader().stopAllLoaders();
1018}
1019
1020void LocalDOMWindow::alert(const String& message)
1021{
1022    if (!m_frame)
1023        return;
1024
1025    m_frame->document()->updateRenderTreeIfNeeded();
1026
1027    FrameHost* host = m_frame->host();
1028    if (!host)
1029        return;
1030
1031    host->chrome().runJavaScriptAlert(m_frame, message);
1032}
1033
1034bool LocalDOMWindow::confirm(const String& message)
1035{
1036    if (!m_frame)
1037        return false;
1038
1039    m_frame->document()->updateRenderTreeIfNeeded();
1040
1041    FrameHost* host = m_frame->host();
1042    if (!host)
1043        return false;
1044
1045    return host->chrome().runJavaScriptConfirm(m_frame, message);
1046}
1047
1048String LocalDOMWindow::prompt(const String& message, const String& defaultValue)
1049{
1050    if (!m_frame)
1051        return String();
1052
1053    m_frame->document()->updateRenderTreeIfNeeded();
1054
1055    FrameHost* host = m_frame->host();
1056    if (!host)
1057        return String();
1058
1059    String returnValue;
1060    if (host->chrome().runJavaScriptPrompt(m_frame, message, defaultValue, returnValue))
1061        return returnValue;
1062
1063    return String();
1064}
1065
1066bool LocalDOMWindow::find(const String& string, bool caseSensitive, bool backwards, bool wrap, bool /*wholeWord*/, bool /*searchInFrames*/, bool /*showDialog*/) const
1067{
1068    if (!isCurrentlyDisplayedInFrame())
1069        return false;
1070
1071    // |m_frame| can be destructed during |Editor::findString()| via
1072    // |Document::updateLayou()|, e.g. event handler removes a frame.
1073    RefPtr<LocalFrame> protectFrame(m_frame);
1074
1075    // FIXME (13016): Support wholeWord, searchInFrames and showDialog
1076    return m_frame->editor().findString(string, !backwards, caseSensitive, wrap, false);
1077}
1078
1079bool LocalDOMWindow::offscreenBuffering() const
1080{
1081    return true;
1082}
1083
1084int LocalDOMWindow::outerHeight() const
1085{
1086    if (!m_frame)
1087        return 0;
1088
1089    FrameHost* host = m_frame->host();
1090    if (!host)
1091        return 0;
1092
1093    if (host->settings().reportScreenSizeInPhysicalPixelsQuirk())
1094        return lroundf(host->chrome().windowRect().height() * host->deviceScaleFactor());
1095    return static_cast<int>(host->chrome().windowRect().height());
1096}
1097
1098int LocalDOMWindow::outerWidth() const
1099{
1100    if (!m_frame)
1101        return 0;
1102
1103    FrameHost* host = m_frame->host();
1104    if (!host)
1105        return 0;
1106
1107    if (host->settings().reportScreenSizeInPhysicalPixelsQuirk())
1108        return lroundf(host->chrome().windowRect().width() * host->deviceScaleFactor());
1109    return static_cast<int>(host->chrome().windowRect().width());
1110}
1111
1112int LocalDOMWindow::innerHeight() const
1113{
1114    if (!m_frame)
1115        return 0;
1116
1117    FrameView* view = m_frame->view();
1118    if (!view)
1119        return 0;
1120
1121    // FIXME: This is potentially too much work. We really only need to know the dimensions of the parent frame's renderer.
1122    if (Frame* parent = m_frame->tree().parent()) {
1123        if (parent && parent->isLocalFrame())
1124            toLocalFrame(parent)->document()->updateLayoutIgnorePendingStylesheets();
1125    }
1126
1127    return adjustForAbsoluteZoom(view->visibleContentRect(IncludeScrollbars).height(), m_frame->pageZoomFactor());
1128}
1129
1130int LocalDOMWindow::innerWidth() const
1131{
1132    if (!m_frame)
1133        return 0;
1134
1135    FrameView* view = m_frame->view();
1136    if (!view)
1137        return 0;
1138
1139    // FIXME: This is potentially too much work. We really only need to know the dimensions of the parent frame's renderer.
1140    if (Frame* parent = m_frame->tree().parent()) {
1141        if (parent && parent->isLocalFrame())
1142            toLocalFrame(parent)->document()->updateLayoutIgnorePendingStylesheets();
1143    }
1144
1145    return adjustForAbsoluteZoom(view->visibleContentRect(IncludeScrollbars).width(), m_frame->pageZoomFactor());
1146}
1147
1148int LocalDOMWindow::screenX() const
1149{
1150    if (!m_frame)
1151        return 0;
1152
1153    FrameHost* host = m_frame->host();
1154    if (!host)
1155        return 0;
1156
1157    if (host->settings().reportScreenSizeInPhysicalPixelsQuirk())
1158        return lroundf(host->chrome().windowRect().x() * host->deviceScaleFactor());
1159    return static_cast<int>(host->chrome().windowRect().x());
1160}
1161
1162int LocalDOMWindow::screenY() const
1163{
1164    if (!m_frame)
1165        return 0;
1166
1167    FrameHost* host = m_frame->host();
1168    if (!host)
1169        return 0;
1170
1171    if (host->settings().reportScreenSizeInPhysicalPixelsQuirk())
1172        return lroundf(host->chrome().windowRect().y() * host->deviceScaleFactor());
1173    return static_cast<int>(host->chrome().windowRect().y());
1174}
1175
1176int LocalDOMWindow::scrollX() const
1177{
1178    if (!m_frame)
1179        return 0;
1180
1181    FrameView* view = m_frame->view();
1182    if (!view)
1183        return 0;
1184
1185    m_frame->document()->updateLayoutIgnorePendingStylesheets();
1186
1187    return adjustForAbsoluteZoom(view->scrollX(), m_frame->pageZoomFactor());
1188}
1189
1190int LocalDOMWindow::scrollY() const
1191{
1192    if (!m_frame)
1193        return 0;
1194
1195    FrameView* view = m_frame->view();
1196    if (!view)
1197        return 0;
1198
1199    m_frame->document()->updateLayoutIgnorePendingStylesheets();
1200
1201    return adjustForAbsoluteZoom(view->scrollY(), m_frame->pageZoomFactor());
1202}
1203
1204bool LocalDOMWindow::closed() const
1205{
1206    return !m_frame;
1207}
1208
1209unsigned LocalDOMWindow::length() const
1210{
1211    if (!isCurrentlyDisplayedInFrame())
1212        return 0;
1213
1214    return m_frame->tree().scopedChildCount();
1215}
1216
1217const AtomicString& LocalDOMWindow::name() const
1218{
1219    if (!isCurrentlyDisplayedInFrame())
1220        return nullAtom;
1221
1222    return m_frame->tree().name();
1223}
1224
1225void LocalDOMWindow::setName(const AtomicString& name)
1226{
1227    if (!isCurrentlyDisplayedInFrame())
1228        return;
1229
1230    m_frame->tree().setName(name);
1231    ASSERT(m_frame->loader().client());
1232    m_frame->loader().client()->didChangeName(name);
1233}
1234
1235void LocalDOMWindow::setStatus(const String& string)
1236{
1237    m_status = string;
1238
1239    if (!m_frame)
1240        return;
1241
1242    FrameHost* host = m_frame->host();
1243    if (!host)
1244        return;
1245
1246    ASSERT(m_frame->document()); // Client calls shouldn't be made when the frame is in inconsistent state.
1247    host->chrome().setStatusbarText(m_frame, m_status);
1248}
1249
1250void LocalDOMWindow::setDefaultStatus(const String& string)
1251{
1252    m_defaultStatus = string;
1253
1254    if (!m_frame)
1255        return;
1256
1257    FrameHost* host = m_frame->host();
1258    if (!host)
1259        return;
1260
1261    ASSERT(m_frame->document()); // Client calls shouldn't be made when the frame is in inconsistent state.
1262    host->chrome().setStatusbarText(m_frame, m_defaultStatus);
1263}
1264
1265LocalDOMWindow* LocalDOMWindow::self() const
1266{
1267    if (!m_frame)
1268        return 0;
1269
1270    return m_frame->domWindow();
1271}
1272
1273LocalDOMWindow* LocalDOMWindow::opener() const
1274{
1275    if (!m_frame)
1276        return 0;
1277
1278    LocalFrame* opener = m_frame->loader().opener();
1279    if (!opener)
1280        return 0;
1281
1282    return opener->domWindow();
1283}
1284
1285LocalDOMWindow* LocalDOMWindow::parent() const
1286{
1287    if (!m_frame)
1288        return 0;
1289
1290    Frame* parent = m_frame->tree().parent();
1291    if (parent)
1292        return parent->domWindow();
1293
1294    return m_frame->domWindow();
1295}
1296
1297LocalDOMWindow* LocalDOMWindow::top() const
1298{
1299    if (!m_frame)
1300        return 0;
1301
1302    return m_frame->tree().top()->domWindow();
1303}
1304
1305Document* LocalDOMWindow::document() const
1306{
1307    return m_document.get();
1308}
1309
1310StyleMedia& LocalDOMWindow::styleMedia() const
1311{
1312    if (!m_media)
1313        m_media = StyleMedia::create(m_frame);
1314    return *m_media;
1315}
1316
1317PassRefPtrWillBeRawPtr<CSSStyleDeclaration> LocalDOMWindow::getComputedStyle(Element* elt, const String& pseudoElt) const
1318{
1319    if (!elt)
1320        return nullptr;
1321
1322    return CSSComputedStyleDeclaration::create(elt, false, pseudoElt);
1323}
1324
1325PassRefPtrWillBeRawPtr<CSSRuleList> LocalDOMWindow::getMatchedCSSRules(Element* element, const String& pseudoElement) const
1326{
1327    if (!element)
1328        return nullptr;
1329
1330    if (!isCurrentlyDisplayedInFrame())
1331        return nullptr;
1332
1333    unsigned colonStart = pseudoElement[0] == ':' ? (pseudoElement[1] == ':' ? 2 : 1) : 0;
1334    CSSSelector::PseudoType pseudoType = CSSSelector::parsePseudoType(AtomicString(pseudoElement.substring(colonStart)));
1335    if (pseudoType == CSSSelector::PseudoUnknown && !pseudoElement.isEmpty())
1336        return nullptr;
1337
1338    unsigned rulesToInclude = StyleResolver::AuthorCSSRules;
1339    PseudoId pseudoId = CSSSelector::pseudoId(pseudoType);
1340    return m_frame->document()->ensureStyleResolver().pseudoCSSRulesForElement(element, pseudoId, rulesToInclude);
1341}
1342
1343PassRefPtrWillBeRawPtr<DOMPoint> LocalDOMWindow::webkitConvertPointFromNodeToPage(Node* node, const DOMPoint* p) const
1344{
1345    if (!node || !p)
1346        return nullptr;
1347
1348    if (!document())
1349        return nullptr;
1350
1351    document()->updateLayoutIgnorePendingStylesheets();
1352
1353    FloatPoint pagePoint(p->x(), p->y());
1354    pagePoint = node->convertToPage(pagePoint);
1355    return DOMPoint::create(pagePoint.x(), pagePoint.y());
1356}
1357
1358PassRefPtrWillBeRawPtr<DOMPoint> LocalDOMWindow::webkitConvertPointFromPageToNode(Node* node, const DOMPoint* p) const
1359{
1360    if (!node || !p)
1361        return nullptr;
1362
1363    if (!document())
1364        return nullptr;
1365
1366    document()->updateLayoutIgnorePendingStylesheets();
1367
1368    FloatPoint nodePoint(p->x(), p->y());
1369    nodePoint = node->convertFromPage(nodePoint);
1370    return DOMPoint::create(nodePoint.x(), nodePoint.y());
1371}
1372
1373double LocalDOMWindow::devicePixelRatio() const
1374{
1375    if (!m_frame)
1376        return 0.0;
1377
1378    return m_frame->devicePixelRatio();
1379}
1380
1381static bool scrollBehaviorFromScrollOptions(const Dictionary& scrollOptions, ScrollBehavior& scrollBehavior, ExceptionState& exceptionState)
1382{
1383    String scrollBehaviorString;
1384    if (!scrollOptions.get("behavior", scrollBehaviorString)) {
1385        scrollBehavior = ScrollBehaviorAuto;
1386        return true;
1387    }
1388
1389    if (ScrollableArea::scrollBehaviorFromString(scrollBehaviorString, scrollBehavior))
1390        return true;
1391
1392    exceptionState.throwTypeError("The ScrollBehavior provided is invalid.");
1393    return false;
1394}
1395
1396void LocalDOMWindow::scrollBy(int x, int y) const
1397{
1398    if (!isCurrentlyDisplayedInFrame())
1399        return;
1400
1401    document()->updateLayoutIgnorePendingStylesheets();
1402
1403    FrameView* view = m_frame->view();
1404    if (!view)
1405        return;
1406
1407    IntSize scaledOffset(x * m_frame->pageZoomFactor(), y * m_frame->pageZoomFactor());
1408    // FIXME: Use scrollBehavior to decide whether to scroll smoothly or instantly.
1409    view->scrollBy(scaledOffset);
1410}
1411
1412void LocalDOMWindow::scrollBy(int x, int y, const Dictionary& scrollOptions, ExceptionState &exceptionState) const
1413{
1414    ScrollBehavior scrollBehavior = ScrollBehaviorAuto;
1415    if (!scrollBehaviorFromScrollOptions(scrollOptions, scrollBehavior, exceptionState))
1416        return;
1417    scrollBy(x, y);
1418}
1419
1420void LocalDOMWindow::scrollTo(int x, int y) const
1421{
1422    if (!isCurrentlyDisplayedInFrame())
1423        return;
1424
1425    document()->updateLayoutIgnorePendingStylesheets();
1426
1427    RefPtr<FrameView> view = m_frame->view();
1428    if (!view)
1429        return;
1430
1431    IntPoint layoutPos(x * m_frame->pageZoomFactor(), y * m_frame->pageZoomFactor());
1432    // FIXME: Use scrollBehavior to decide whether to scroll smoothly or instantly.
1433    view->setScrollPosition(layoutPos);
1434}
1435
1436void LocalDOMWindow::scrollTo(int x, int y, const Dictionary& scrollOptions, ExceptionState& exceptionState) const
1437{
1438    ScrollBehavior scrollBehavior = ScrollBehaviorAuto;
1439    if (!scrollBehaviorFromScrollOptions(scrollOptions, scrollBehavior, exceptionState))
1440        return;
1441    scrollTo(x, y);
1442}
1443
1444void LocalDOMWindow::moveBy(float x, float y) const
1445{
1446    if (!m_frame || !m_frame->isMainFrame())
1447        return;
1448
1449    FrameHost* host = m_frame->host();
1450    if (!host)
1451        return;
1452
1453    FloatRect windowRect = host->chrome().windowRect();
1454    windowRect.move(x, y);
1455    // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
1456    host->chrome().setWindowRect(adjustWindowRect(*m_frame, windowRect));
1457}
1458
1459void LocalDOMWindow::moveTo(float x, float y) const
1460{
1461    if (!m_frame || !m_frame->isMainFrame())
1462        return;
1463
1464    FrameHost* host = m_frame->host();
1465    if (!host)
1466        return;
1467
1468    FloatRect windowRect = host->chrome().windowRect();
1469    windowRect.setLocation(FloatPoint(x, y));
1470    // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
1471    host->chrome().setWindowRect(adjustWindowRect(*m_frame, windowRect));
1472}
1473
1474void LocalDOMWindow::resizeBy(float x, float y) const
1475{
1476    if (!m_frame || !m_frame->isMainFrame())
1477        return;
1478
1479    FrameHost* host = m_frame->host();
1480    if (!host)
1481        return;
1482
1483    FloatRect fr = host->chrome().windowRect();
1484    FloatSize dest = fr.size() + FloatSize(x, y);
1485    FloatRect update(fr.location(), dest);
1486    host->chrome().setWindowRect(adjustWindowRect(*m_frame, update));
1487}
1488
1489void LocalDOMWindow::resizeTo(float width, float height) const
1490{
1491    if (!m_frame || !m_frame->isMainFrame())
1492        return;
1493
1494    FrameHost* host = m_frame->host();
1495    if (!host)
1496        return;
1497
1498    FloatRect fr = host->chrome().windowRect();
1499    FloatSize dest = FloatSize(width, height);
1500    FloatRect update(fr.location(), dest);
1501    host->chrome().setWindowRect(adjustWindowRect(*m_frame, update));
1502}
1503
1504int LocalDOMWindow::requestAnimationFrame(PassOwnPtr<RequestAnimationFrameCallback> callback)
1505{
1506    callback->m_useLegacyTimeBase = false;
1507    if (Document* d = document())
1508        return d->requestAnimationFrame(callback);
1509    return 0;
1510}
1511
1512int LocalDOMWindow::webkitRequestAnimationFrame(PassOwnPtr<RequestAnimationFrameCallback> callback)
1513{
1514    callback->m_useLegacyTimeBase = true;
1515    if (Document* d = document())
1516        return d->requestAnimationFrame(callback);
1517    return 0;
1518}
1519
1520void LocalDOMWindow::cancelAnimationFrame(int id)
1521{
1522    if (Document* d = document())
1523        d->cancelAnimationFrame(id);
1524}
1525
1526DOMWindowCSS& LocalDOMWindow::css() const
1527{
1528    if (!m_css)
1529        m_css = DOMWindowCSS::create();
1530    return *m_css;
1531}
1532
1533static void didAddStorageEventListener(LocalDOMWindow* window)
1534{
1535    // Creating these WebCore::Storage objects informs the system that we'd like to receive
1536    // notifications about storage events that might be triggered in other processes. Rather
1537    // than subscribe to these notifications explicitly, we subscribe to them implicitly to
1538    // simplify the work done by the system.
1539    window->localStorage(IGNORE_EXCEPTION);
1540    window->sessionStorage(IGNORE_EXCEPTION);
1541}
1542
1543bool LocalDOMWindow::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
1544{
1545    if (!EventTarget::addEventListener(eventType, listener, useCapture))
1546        return false;
1547
1548    if (m_frame && m_frame->host())
1549        m_frame->host()->eventHandlerRegistry().didAddEventHandler(*this, eventType);
1550
1551    if (Document* document = this->document()) {
1552        document->addListenerTypeIfNeeded(eventType);
1553        if (isTouchEventType(eventType))
1554            document->didAddTouchEventHandler(document);
1555        else if (eventType == EventTypeNames::storage)
1556            didAddStorageEventListener(this);
1557    }
1558
1559    lifecycleNotifier().notifyAddEventListener(this, eventType);
1560
1561    if (eventType == EventTypeNames::unload) {
1562        UseCounter::count(document(), UseCounter::DocumentUnloadRegistered);
1563        addUnloadEventListener(this);
1564    } else if (eventType == EventTypeNames::beforeunload) {
1565        UseCounter::count(document(), UseCounter::DocumentBeforeUnloadRegistered);
1566        if (allowsBeforeUnloadListeners(this)) {
1567            // This is confusingly named. It doesn't actually add the listener. It just increments a count
1568            // so that we know we have listeners registered for the purposes of determining if we can
1569            // fast terminate the renderer process.
1570            addBeforeUnloadEventListener(this);
1571        } else {
1572            // Subframes return false from allowsBeforeUnloadListeners.
1573            UseCounter::count(document(), UseCounter::SubFrameBeforeUnloadRegistered);
1574        }
1575    }
1576
1577    return true;
1578}
1579
1580bool LocalDOMWindow::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
1581{
1582    if (!EventTarget::removeEventListener(eventType, listener, useCapture))
1583        return false;
1584
1585    if (m_frame && m_frame->host())
1586        m_frame->host()->eventHandlerRegistry().didRemoveEventHandler(*this, eventType);
1587
1588    if (Document* document = this->document()) {
1589        if (isTouchEventType(eventType))
1590            document->didRemoveTouchEventHandler(document);
1591    }
1592
1593    lifecycleNotifier().notifyRemoveEventListener(this, eventType);
1594
1595    if (eventType == EventTypeNames::unload) {
1596        removeUnloadEventListener(this);
1597    } else if (eventType == EventTypeNames::beforeunload && allowsBeforeUnloadListeners(this)) {
1598        removeBeforeUnloadEventListener(this);
1599    }
1600
1601    return true;
1602}
1603
1604void LocalDOMWindow::dispatchLoadEvent()
1605{
1606    RefPtrWillBeRawPtr<Event> loadEvent(Event::create(EventTypeNames::load));
1607    if (m_frame && m_frame->loader().documentLoader() && !m_frame->loader().documentLoader()->timing()->loadEventStart()) {
1608        // The DocumentLoader (and thus its DocumentLoadTiming) might get destroyed while dispatching
1609        // the event, so protect it to prevent writing the end time into freed memory.
1610        RefPtr<DocumentLoader> documentLoader = m_frame->loader().documentLoader();
1611        DocumentLoadTiming* timing = documentLoader->timing();
1612        timing->markLoadEventStart();
1613        dispatchEvent(loadEvent, document());
1614        timing->markLoadEventEnd();
1615    } else
1616        dispatchEvent(loadEvent, document());
1617
1618    // For load events, send a separate load event to the enclosing frame only.
1619    // This is a DOM extension and is independent of bubbling/capturing rules of
1620    // the DOM.
1621    FrameOwner* owner = m_frame ? m_frame->owner() : 0;
1622    if (owner)
1623        owner->dispatchLoad();
1624
1625    TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "MarkLoad", "data", InspectorMarkLoadEvent::data(frame()));
1626    // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
1627    InspectorInstrumentation::loadEventFired(frame());
1628}
1629
1630bool LocalDOMWindow::dispatchEvent(PassRefPtrWillBeRawPtr<Event> prpEvent, PassRefPtrWillBeRawPtr<EventTarget> prpTarget)
1631{
1632    ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
1633
1634    RefPtrWillBeRawPtr<EventTarget> protect(this);
1635    RefPtrWillBeRawPtr<Event> event = prpEvent;
1636
1637    event->setTarget(prpTarget ? prpTarget : this);
1638    event->setCurrentTarget(this);
1639    event->setEventPhase(Event::AT_TARGET);
1640
1641    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "EventDispatch", "type", event->type().ascii());
1642    // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
1643    InspectorInstrumentationCookie cookie = InspectorInstrumentation::willDispatchEventOnWindow(frame(), *event, this);
1644
1645    bool result = fireEventListeners(event.get());
1646
1647    InspectorInstrumentation::didDispatchEventOnWindow(cookie);
1648
1649    return result;
1650}
1651
1652void LocalDOMWindow::removeAllEventListenersInternal(BroadcastListenerRemoval mode)
1653{
1654    EventTarget::removeAllEventListeners();
1655
1656    lifecycleNotifier().notifyRemoveAllEventListeners(this);
1657
1658    if (mode == DoBroadcastListenerRemoval) {
1659        if (m_frame && m_frame->host())
1660            m_frame->host()->eventHandlerRegistry().didRemoveAllEventHandlers(*this);
1661
1662        if (Document* document = this->document())
1663            document->didClearTouchEventHandlers(document);
1664    }
1665
1666    removeAllUnloadEventListeners(this);
1667    removeAllBeforeUnloadEventListeners(this);
1668}
1669
1670void LocalDOMWindow::removeAllEventListeners()
1671{
1672    removeAllEventListenersInternal(DoBroadcastListenerRemoval);
1673}
1674
1675void LocalDOMWindow::finishedLoading()
1676{
1677    if (m_shouldPrintWhenFinishedLoading) {
1678        m_shouldPrintWhenFinishedLoading = false;
1679        print();
1680    }
1681}
1682
1683void LocalDOMWindow::setLocation(const String& urlString, LocalDOMWindow* callingWindow, LocalDOMWindow* enteredWindow, SetLocationLocking locking)
1684{
1685    if (!isCurrentlyDisplayedInFrame())
1686        return;
1687
1688    Document* activeDocument = callingWindow->document();
1689    if (!activeDocument)
1690        return;
1691
1692    ASSERT(m_frame);
1693    if (!activeDocument->canNavigate(*m_frame))
1694        return;
1695
1696    LocalFrame* firstFrame = enteredWindow->frame();
1697    if (!firstFrame)
1698        return;
1699
1700    KURL completedURL = firstFrame->document()->completeURL(urlString);
1701    if (completedURL.isNull())
1702        return;
1703
1704    if (isInsecureScriptAccess(*callingWindow, completedURL))
1705        return;
1706
1707    // We want a new history item if we are processing a user gesture.
1708    m_frame->navigationScheduler().scheduleLocationChange(activeDocument,
1709        // FIXME: What if activeDocument()->frame() is 0?
1710        completedURL, Referrer(activeDocument->outgoingReferrer(), activeDocument->referrerPolicy()),
1711        locking != LockHistoryBasedOnGestureState);
1712}
1713
1714void LocalDOMWindow::printErrorMessage(const String& message)
1715{
1716    if (message.isEmpty())
1717        return;
1718
1719    frameConsole()->addMessage(JSMessageSource, ErrorMessageLevel, message);
1720}
1721
1722// FIXME: Once we're throwing exceptions for cross-origin access violations, we will always sanitize the target
1723// frame details, so we can safely combine 'crossDomainAccessErrorMessage' with this method after considering
1724// exactly which details may be exposed to JavaScript.
1725//
1726// http://crbug.com/17325
1727String LocalDOMWindow::sanitizedCrossDomainAccessErrorMessage(LocalDOMWindow* callingWindow)
1728{
1729    if (!callingWindow || !callingWindow->document())
1730        return String();
1731
1732    const KURL& callingWindowURL = callingWindow->document()->url();
1733    if (callingWindowURL.isNull())
1734        return String();
1735
1736    ASSERT(!callingWindow->document()->securityOrigin()->canAccess(document()->securityOrigin()));
1737
1738    SecurityOrigin* activeOrigin = callingWindow->document()->securityOrigin();
1739    String message = "Blocked a frame with origin \"" + activeOrigin->toString() + "\" from accessing a cross-origin frame.";
1740
1741    // FIXME: Evaluate which details from 'crossDomainAccessErrorMessage' may safely be reported to JavaScript.
1742
1743    return message;
1744}
1745
1746String LocalDOMWindow::crossDomainAccessErrorMessage(LocalDOMWindow* callingWindow)
1747{
1748    if (!callingWindow || !callingWindow->document())
1749        return String();
1750
1751    const KURL& callingWindowURL = callingWindow->document()->url();
1752    if (callingWindowURL.isNull())
1753        return String();
1754
1755    ASSERT(!callingWindow->document()->securityOrigin()->canAccess(document()->securityOrigin()));
1756
1757    // FIXME: This message, and other console messages, have extra newlines. Should remove them.
1758    SecurityOrigin* activeOrigin = callingWindow->document()->securityOrigin();
1759    SecurityOrigin* targetOrigin = document()->securityOrigin();
1760    String message = "Blocked a frame with origin \"" + activeOrigin->toString() + "\" from accessing a frame with origin \"" + targetOrigin->toString() + "\". ";
1761
1762    // Sandbox errors: Use the origin of the frames' location, rather than their actual origin (since we know that at least one will be "null").
1763    KURL activeURL = callingWindow->document()->url();
1764    KURL targetURL = document()->url();
1765    if (document()->isSandboxed(SandboxOrigin) || callingWindow->document()->isSandboxed(SandboxOrigin)) {
1766        message = "Blocked a frame at \"" + SecurityOrigin::create(activeURL)->toString() + "\" from accessing a frame at \"" + SecurityOrigin::create(targetURL)->toString() + "\". ";
1767        if (document()->isSandboxed(SandboxOrigin) && callingWindow->document()->isSandboxed(SandboxOrigin))
1768            return "Sandbox access violation: " + message + " Both frames are sandboxed and lack the \"allow-same-origin\" flag.";
1769        if (document()->isSandboxed(SandboxOrigin))
1770            return "Sandbox access violation: " + message + " The frame being accessed is sandboxed and lacks the \"allow-same-origin\" flag.";
1771        return "Sandbox access violation: " + message + " The frame requesting access is sandboxed and lacks the \"allow-same-origin\" flag.";
1772    }
1773
1774    // Protocol errors: Use the URL's protocol rather than the origin's protocol so that we get a useful message for non-heirarchal URLs like 'data:'.
1775    if (targetOrigin->protocol() != activeOrigin->protocol())
1776        return message + " The frame requesting access has a protocol of \"" + activeURL.protocol() + "\", the frame being accessed has a protocol of \"" + targetURL.protocol() + "\". Protocols must match.\n";
1777
1778    // 'document.domain' errors.
1779    if (targetOrigin->domainWasSetInDOM() && activeOrigin->domainWasSetInDOM())
1780        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.";
1781    if (activeOrigin->domainWasSetInDOM())
1782        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.";
1783    if (targetOrigin->domainWasSetInDOM())
1784        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.";
1785
1786    // Default.
1787    return message + "Protocols, domains, and ports must match.";
1788}
1789
1790bool LocalDOMWindow::isInsecureScriptAccess(LocalDOMWindow& callingWindow, const String& urlString)
1791{
1792    if (!protocolIsJavaScript(urlString))
1793        return false;
1794
1795    // If this LocalDOMWindow isn't currently active in the LocalFrame, then there's no
1796    // way we should allow the access.
1797    // FIXME: Remove this check if we're able to disconnect LocalDOMWindow from
1798    // LocalFrame on navigation: https://bugs.webkit.org/show_bug.cgi?id=62054
1799    if (isCurrentlyDisplayedInFrame()) {
1800        // FIXME: Is there some way to eliminate the need for a separate "callingWindow == this" check?
1801        if (&callingWindow == this)
1802            return false;
1803
1804        // FIXME: The name canAccess seems to be a roundabout way to ask "can execute script".
1805        // Can we name the SecurityOrigin function better to make this more clear?
1806        if (callingWindow.document()->securityOrigin()->canAccess(document()->securityOrigin()))
1807            return false;
1808    }
1809
1810    printErrorMessage(crossDomainAccessErrorMessage(&callingWindow));
1811    return true;
1812}
1813
1814PassRefPtrWillBeRawPtr<LocalDOMWindow> LocalDOMWindow::open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
1815    LocalDOMWindow* callingWindow, LocalDOMWindow* enteredWindow)
1816{
1817    if (!isCurrentlyDisplayedInFrame())
1818        return nullptr;
1819    Document* activeDocument = callingWindow->document();
1820    if (!activeDocument)
1821        return nullptr;
1822    LocalFrame* firstFrame = enteredWindow->frame();
1823    if (!firstFrame)
1824        return nullptr;
1825
1826    if (!enteredWindow->allowPopUp()) {
1827        // Because FrameTree::find() returns true for empty strings, we must check for empty frame names.
1828        // Otherwise, illegitimate window.open() calls with no name will pass right through the popup blocker.
1829        if (frameName.isEmpty() || !m_frame->tree().find(frameName))
1830            return nullptr;
1831    }
1832
1833    // Get the target frame for the special cases of _top and _parent.
1834    // In those cases, we schedule a location change right now and return early.
1835    Frame* targetFrame = 0;
1836    if (frameName == "_top")
1837        targetFrame = m_frame->tree().top();
1838    else if (frameName == "_parent") {
1839        if (Frame* parent = m_frame->tree().parent())
1840            targetFrame = parent;
1841        else
1842            targetFrame = m_frame;
1843    }
1844    // FIXME: Navigating RemoteFrames is not yet supported.
1845    if (targetFrame && targetFrame->isLocalFrame()) {
1846        if (!activeDocument->canNavigate(*targetFrame))
1847            return nullptr;
1848
1849        KURL completedURL = firstFrame->document()->completeURL(urlString);
1850
1851        if (targetFrame->domWindow()->isInsecureScriptAccess(*callingWindow, completedURL))
1852            return targetFrame->domWindow();
1853
1854        if (urlString.isEmpty())
1855            return targetFrame->domWindow();
1856
1857        // For whatever reason, Firefox uses the first window rather than the active window to
1858        // determine the outgoing referrer. We replicate that behavior here.
1859        toLocalFrame(targetFrame)->navigationScheduler().scheduleLocationChange(
1860            activeDocument,
1861            completedURL,
1862            Referrer(firstFrame->document()->outgoingReferrer(), firstFrame->document()->referrerPolicy()),
1863            false);
1864        return targetFrame->domWindow();
1865    }
1866
1867    WindowFeatures windowFeatures(windowFeaturesString);
1868    LocalFrame* result = createWindow(urlString, frameName, windowFeatures, *callingWindow, *firstFrame, *m_frame);
1869    return result ? result->domWindow() : 0;
1870}
1871
1872void LocalDOMWindow::showModalDialog(const String& urlString, const String& dialogFeaturesString,
1873    LocalDOMWindow* callingWindow, LocalDOMWindow* enteredWindow, PrepareDialogFunction function, void* functionContext)
1874{
1875    if (!isCurrentlyDisplayedInFrame())
1876        return;
1877    LocalFrame* activeFrame = callingWindow->frame();
1878    if (!activeFrame)
1879        return;
1880    LocalFrame* firstFrame = enteredWindow->frame();
1881    if (!firstFrame)
1882        return;
1883
1884    if (!canShowModalDialogNow(m_frame) || !enteredWindow->allowPopUp())
1885        return;
1886
1887    UseCounter::countDeprecation(this, UseCounter::ShowModalDialog);
1888
1889    WindowFeatures windowFeatures(dialogFeaturesString, screenAvailableRect(m_frame->view()));
1890    LocalFrame* dialogFrame = createWindow(urlString, emptyAtom, windowFeatures,
1891        *callingWindow, *firstFrame, *m_frame, function, functionContext);
1892    if (!dialogFrame)
1893        return;
1894    UserGestureIndicatorDisabler disabler;
1895    dialogFrame->host()->chrome().runModal();
1896}
1897
1898LocalDOMWindow* LocalDOMWindow::anonymousIndexedGetter(uint32_t index)
1899{
1900    LocalFrame* frame = this->frame();
1901    if (!frame)
1902        return 0;
1903
1904    Frame* child = frame->tree().scopedChild(index);
1905    if (child)
1906        return child->domWindow();
1907
1908    return 0;
1909}
1910
1911DOMWindowLifecycleNotifier& LocalDOMWindow::lifecycleNotifier()
1912{
1913    return static_cast<DOMWindowLifecycleNotifier&>(LifecycleContext<LocalDOMWindow>::lifecycleNotifier());
1914}
1915
1916PassOwnPtr<LifecycleNotifier<LocalDOMWindow> > LocalDOMWindow::createLifecycleNotifier()
1917{
1918    return DOMWindowLifecycleNotifier::create(this);
1919}
1920
1921void LocalDOMWindow::trace(Visitor* visitor)
1922{
1923    visitor->trace(m_document);
1924    visitor->trace(m_screen);
1925    visitor->trace(m_history);
1926    visitor->trace(m_locationbar);
1927    visitor->trace(m_menubar);
1928    visitor->trace(m_personalbar);
1929    visitor->trace(m_scrollbars);
1930    visitor->trace(m_statusbar);
1931    visitor->trace(m_toolbar);
1932    visitor->trace(m_console);
1933    visitor->trace(m_navigator);
1934    visitor->trace(m_location);
1935    visitor->trace(m_media);
1936    visitor->trace(m_sessionStorage);
1937    visitor->trace(m_localStorage);
1938    visitor->trace(m_applicationCache);
1939    visitor->trace(m_performance);
1940    visitor->trace(m_css);
1941    visitor->trace(m_eventQueue);
1942    WillBeHeapSupplementable<LocalDOMWindow>::trace(visitor);
1943    EventTargetWithInlineData::trace(visitor);
1944}
1945
1946} // namespace WebCore
1947