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