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