Rename DOMWindow to LocalDOMWindow

Source/core/frame/LocalDOMWindow.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
-#include "core/frame/DOMWindow.h"
+#include "core/frame/LocalDOMWindow.h"
 
 #include "bindings/v8/ExceptionMessages.h"
 #include "bindings/v8/ExceptionState.h"
 #include "bindings/v8/ExceptionStatePlaceholder.h"
 #include "bindings/v8/ScriptCallStackFactory.h"
 #include "bindings/v8/ScriptController.h"
 #include "bindings/v8/SerializedScriptValue.h"
 #include "core/css/CSSComputedStyleDeclaration.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/DOMWindowCSS.h"
@@ skipping 69 matching lines @@
 #include "wtf/text/WTFString.h"
 #include <algorithm>
 
 using std::min;
 using std::max;
 
 namespace WebCore {
 
 class PostMessageTimer FINAL : public SuspendableTimer {
 public:
-    PostMessageTimer(DOMWindow& window, PassRefPtr<SerializedScriptValue> message, const String& sourceOrigin, PassRefPtrWillBeRawPtr<DOMWindow> source, PassOwnPtr<MessagePortChannelArray> channels, SecurityOrigin* targetOrigin, PassRefPtrWillBeRawPtr<ScriptCallStack> stackTrace, UserGestureToken* userGestureToken)
+    PostMessageTimer(LocalDOMWindow& window, PassRefPtr<SerializedScriptValue> message, const String& sourceOrigin, PassRefPtrWillBeRawPtr<LocalDOMWindow> source, PassOwnPtr<MessagePortChannelArray> channels, SecurityOrigin* targetOrigin, PassRefPtrWillBeRawPtr<ScriptCallStack> stackTrace, UserGestureToken* userGestureToken)
         : SuspendableTimer(window.document())
         , m_window(window)
         , m_message(message)
         , m_origin(sourceOrigin)
         , m_source(source)
         , m_channels(channels)
         , m_targetOrigin(targetOrigin)
         , m_stackTrace(stackTrace)
         , m_userGestureToken(userGestureToken)
     {
     }
 
     PassRefPtrWillBeRawPtr<MessageEvent> event()
     {
         return MessageEvent::create(m_channels.release(), m_message, m_origin, String(), m_source.get());
 
     }
     SecurityOrigin* targetOrigin() const { return m_targetOrigin.get(); }
     ScriptCallStack* stackTrace() const { return m_stackTrace.get(); }
     UserGestureToken* userGestureToken() const { return m_userGestureToken.get(); }
 
 private:
     virtual void fired() OVERRIDE
     {
         m_window->postMessageTimerFired(adoptPtr(this));
         // This object is deleted now.
     }
 
-    RefPtrWillBePersistent<DOMWindow> m_window;
+    RefPtrWillBePersistent<LocalDOMWindow> m_window;
     RefPtr<SerializedScriptValue> m_message;
     String m_origin;
-    RefPtrWillBePersistent<DOMWindow> m_source;
+    RefPtrWillBePersistent<LocalDOMWindow> m_source;
     OwnPtr<MessagePortChannelArray> m_channels;
     RefPtr<SecurityOrigin> m_targetOrigin;
     RefPtrWillBePersistent<ScriptCallStack> m_stackTrace;
     RefPtr<UserGestureToken> m_userGestureToken;
 };
 
 static void disableSuddenTermination()
 {
     blink::Platform::current()->suddenTerminationChanged(false);
 }
 
 static void enableSuddenTermination()
 {
     blink::Platform::current()->suddenTerminationChanged(true);
 }
 
-typedef HashCountedSet<DOMWindow*> DOMWindowSet;
+typedef HashCountedSet<LocalDOMWindow*> DOMWindowSet;
 
 static DOMWindowSet& windowsWithUnloadEventListeners()
 {
     DEFINE_STATIC_LOCAL(DOMWindowSet, windowsWithUnloadEventListeners, ());
     return windowsWithUnloadEventListeners;
 }
 
 static DOMWindowSet& windowsWithBeforeUnloadEventListeners()
 {
     DEFINE_STATIC_LOCAL(DOMWindowSet, windowsWithBeforeUnloadEventListeners, ());
     return windowsWithBeforeUnloadEventListeners;
 }
 
-static void addUnloadEventListener(DOMWindow* domWindow)
+static void addUnloadEventListener(LocalDOMWindow* domWindow)
 {
     DOMWindowSet& set = windowsWithUnloadEventListeners();
     if (set.isEmpty())
         disableSuddenTermination();
     set.add(domWindow);
 }
 
-static void removeUnloadEventListener(DOMWindow* domWindow)
+static void removeUnloadEventListener(LocalDOMWindow* domWindow)
 {
     DOMWindowSet& set = windowsWithUnloadEventListeners();
     DOMWindowSet::iterator it = set.find(domWindow);
     if (it == set.end())
         return;
     set.remove(it);
     if (set.isEmpty())
         enableSuddenTermination();
 }
 
-static void removeAllUnloadEventListeners(DOMWindow* domWindow)
+static void removeAllUnloadEventListeners(LocalDOMWindow* domWindow)
 {
     DOMWindowSet& set = windowsWithUnloadEventListeners();
     DOMWindowSet::iterator it = set.find(domWindow);
     if (it == set.end())
         return;
     set.removeAll(it);
     if (set.isEmpty())
         enableSuddenTermination();
 }
 
-static void addBeforeUnloadEventListener(DOMWindow* domWindow)
+static void addBeforeUnloadEventListener(LocalDOMWindow* domWindow)
 {
     DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();
     if (set.isEmpty())
         disableSuddenTermination();
     set.add(domWindow);
 }
 
-static void removeBeforeUnloadEventListener(DOMWindow* domWindow)
+static void removeBeforeUnloadEventListener(LocalDOMWindow* domWindow)
 {
     DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();
     DOMWindowSet::iterator it = set.find(domWindow);
     if (it == set.end())
         return;
     set.remove(it);
     if (set.isEmpty())
         enableSuddenTermination();
 }
 
-static void removeAllBeforeUnloadEventListeners(DOMWindow* domWindow)
+static void removeAllBeforeUnloadEventListeners(LocalDOMWindow* domWindow)
 {
     DOMWindowSet& set = windowsWithBeforeUnloadEventListeners();
     DOMWindowSet::iterator it = set.find(domWindow);
     if (it == set.end())
         return;
     set.removeAll(it);
     if (set.isEmpty())
         enableSuddenTermination();
 }
 
-static bool allowsBeforeUnloadListeners(DOMWindow* window)
+static bool allowsBeforeUnloadListeners(LocalDOMWindow* window)
 {
     ASSERT_ARG(window, window);
     LocalFrame* frame = window->frame();
     if (!frame)
         return false;
     return frame->isMainFrame();
 }
 
-unsigned DOMWindow::pendingUnloadEventListeners() const
+unsigned LocalDOMWindow::pendingUnloadEventListeners() const
 {
-    return windowsWithUnloadEventListeners().count(const_cast<DOMWindow*>(this));
+    return windowsWithUnloadEventListeners().count(const_cast<LocalDOMWindow*>(this));
 }
 
 // This function:
 // 1) Validates the pending changes are not changing any value to NaN; in that case keep original value.
 // 2) Constrains the window rect to the minimum window size and no bigger than the float rect's dimensions.
 // 3) Constrains the window rect to within the top and left boundaries of the available screen rect.
 // 4) Constrains the window rect to within the bottom and right boundaries of the available screen rect.
 // 5) Translate the window rect coordinates to be within the coordinate space of the screen.
-FloatRect DOMWindow::adjustWindowRect(LocalFrame& frame, const FloatRect& pendingChanges)
+FloatRect LocalDOMWindow::adjustWindowRect(LocalFrame& frame, const FloatRect& pendingChanges)
 {
     FrameHost* host = frame.host();
     ASSERT(host);
 
     FloatRect screen = screenAvailableRect(frame.view());
     FloatRect window = host->chrome().windowRect();
 
     // Make sure we're in a valid state before adjusting dimensions.
     ASSERT(std::isfinite(screen.x()));
     ASSERT(std::isfinite(screen.y()));
@@ skipping 21 matching lines @@
     if (window.height())
         window.setHeight(min(max(minimumSize.height(), window.height()), screen.height()));
 
     // Constrain the window position within the valid screen area.
     window.setX(max(screen.x(), min(window.x(), screen.maxX() - window.width())));
     window.setY(max(screen.y(), min(window.y(), screen.maxY() - window.height())));
 
     return window;
 }
 
-bool DOMWindow::allowPopUp(LocalFrame& firstFrame)
+bool LocalDOMWindow::allowPopUp(LocalFrame& firstFrame)
 {
     if (UserGestureIndicator::processingUserGesture())
         return true;
 
     Settings* settings = firstFrame.settings();
     return settings && settings->javaScriptCanOpenWindowsAutomatically();
 }
 
-bool DOMWindow::allowPopUp()
+bool LocalDOMWindow::allowPopUp()
 {
     return m_frame && allowPopUp(*m_frame);
 }
 
-bool DOMWindow::canShowModalDialogNow(const LocalFrame* frame)
+bool LocalDOMWindow::canShowModalDialogNow(const LocalFrame* frame)
 {
     if (!frame)
         return false;
     FrameHost* host = frame->host();
     if (!host)
         return false;
     return host->chrome().canRunModalNow();
 }
 
-DOMWindow::DOMWindow(LocalFrame& frame)
+LocalDOMWindow::LocalDOMWindow(LocalFrame& frame)
     : FrameDestructionObserver(&frame)
     , m_shouldPrintWhenFinishedLoading(false)
 #if ASSERT_ENABLED
     , m_hasBeenReset(false)
 #endif
 {
     ScriptWrappable::init(this);
 }
 
-void DOMWindow::clearDocument()
+void LocalDOMWindow::clearDocument()
 {
     if (!m_document)
         return;
 
     if (m_document->isActive()) {
         // FIXME: We don't call willRemove here. Why is that OK?
         // This detach() call is also mostly redundant. Most of the calls to
         // this function come via DocumentLoader::createWriterFor, which
         // always detaches the previous Document first. Only XSLTProcessor
         // depends on this detach() call, so it seems like there's some room
         // for cleanup.
         m_document->detach();
     }
 
     // FIXME: This should be part of ActiveDOMObject shutdown
     clearEventQueue();
 
     m_document->clearDOMWindow();
     m_document = nullptr;
 }
 
-void DOMWindow::clearEventQueue()
+void LocalDOMWindow::clearEventQueue()
 {
     if (!m_eventQueue)
         return;
     m_eventQueue->close();
     m_eventQueue.clear();
 }
 
-void DOMWindow::acceptLanguagesChanged()
+void LocalDOMWindow::acceptLanguagesChanged()
 {
     if (m_navigator)
         m_navigator->setLanguagesChanged();
 
     dispatchEvent(Event::create(EventTypeNames::languagechange));
 }
 
-PassRefPtrWillBeRawPtr<Document> DOMWindow::createDocument(const String& mimeType, const DocumentInit& init, bool forceXHTML)
+PassRefPtrWillBeRawPtr<Document> LocalDOMWindow::createDocument(const String& mimeType, const DocumentInit& init, bool forceXHTML)
 {
     RefPtrWillBeRawPtr<Document> document = nullptr;
     if (forceXHTML) {
         // This is a hack for XSLTProcessor. See XSLTProcessor::createDocumentFromSource().
         document = Document::create(init);
     } else {
         document = DOMImplementation::createDocument(mimeType, init, init.frame() ? init.frame()->inViewSourceMode() : false);
         if (document->isPluginDocument() && document->isSandboxed(SandboxPlugins))
             document = SinkDocument::create(init);
     }
 
     return document.release();
 }
 
-PassRefPtrWillBeRawPtr<Document> DOMWindow::installNewDocument(const String& mimeType, const DocumentInit& init, bool forceXHTML)
+PassRefPtrWillBeRawPtr<Document> LocalDOMWindow::installNewDocument(const String& mimeType, const DocumentInit& init, bool forceXHTML)
 {
     ASSERT(init.frame() == m_frame);
 
     clearDocument();
 
     m_document = createDocument(mimeType, init, forceXHTML);
     m_eventQueue = DOMWindowEventQueue::create(m_document.get());
     m_document->attach();
 
     if (!m_frame) {
@@ skipping 16 matching lines @@
 
     if (m_frame->isMainFrame()) {
         if (m_document->hasTouchEventHandlers())
             m_frame->host()->chrome().client().needTouchEvents(true);
     }
 
     // FIXME: Oilpan: Remove .get() when m_document becomes Member<>.
     return m_document.get();
 }
 
-EventQueue* DOMWindow::eventQueue() const
+EventQueue* LocalDOMWindow::eventQueue() const
 {
     return m_eventQueue.get();
 }
 
-void DOMWindow::enqueueWindowEvent(PassRefPtrWillBeRawPtr<Event> event)
+void LocalDOMWindow::enqueueWindowEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     if (!m_eventQueue)
         return;
     event->setTarget(this);
     m_eventQueue->enqueueEvent(event);
 }
 
-void DOMWindow::enqueueDocumentEvent(PassRefPtrWillBeRawPtr<Event> event)
+void LocalDOMWindow::enqueueDocumentEvent(PassRefPtrWillBeRawPtr<Event> event)
 {
     if (!m_eventQueue)
         return;
     event->setTarget(m_document.get());
     m_eventQueue->enqueueEvent(event);
 }
 
-void DOMWindow::dispatchWindowLoadEvent()
+void LocalDOMWindow::dispatchWindowLoadEvent()
 {
     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
     dispatchLoadEvent();
 }
 
-void DOMWindow::documentWasClosed()
+void LocalDOMWindow::documentWasClosed()
 {
     dispatchWindowLoadEvent();
     enqueuePageshowEvent(PageshowEventNotPersisted);
     if (m_pendingStateObject)
         enqueuePopstateEvent(m_pendingStateObject.release());
 }
 
-void DOMWindow::enqueuePageshowEvent(PageshowEventPersistence persisted)
+void LocalDOMWindow::enqueuePageshowEvent(PageshowEventPersistence persisted)
 {
     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36334 Pageshow event needs to fire asynchronously.
     // As per spec pageshow must be triggered asynchronously.
     // However to be compatible with other browsers blink fires pageshow synchronously.
     dispatchEvent(PageTransitionEvent::create(EventTypeNames::pageshow, persisted), m_document.get());
 }
 
-void DOMWindow::enqueueHashchangeEvent(const String& oldURL, const String& newURL)
+void LocalDOMWindow::enqueueHashchangeEvent(const String& oldURL, const String& newURL)
 {
     enqueueWindowEvent(HashChangeEvent::create(oldURL, newURL));
 }
 
-void DOMWindow::enqueuePopstateEvent(PassRefPtr<SerializedScriptValue> stateObject)
+void LocalDOMWindow::enqueuePopstateEvent(PassRefPtr<SerializedScriptValue> stateObject)
 {
     if (!ContextFeatures::pushStateEnabled(document()))
         return;
 
     // FIXME: https://bugs.webkit.org/show_bug.cgi?id=36202 Popstate event needs to fire asynchronously
     dispatchEvent(PopStateEvent::create(stateObject, &history()));
 }
 
-void DOMWindow::statePopped(PassRefPtr<SerializedScriptValue> stateObject)
+void LocalDOMWindow::statePopped(PassRefPtr<SerializedScriptValue> stateObject)
 {
     if (!frame())
         return;
 
     // Per step 11 of section 6.5.9 (history traversal) of the HTML5 spec, we
     // defer firing of popstate until we're in the complete state.
     if (document()->isLoadCompleted())
         enqueuePopstateEvent(stateObject);
     else
         m_pendingStateObject = stateObject;
 }
 
-DOMWindow::~DOMWindow()
+LocalDOMWindow::~LocalDOMWindow()
 {
     ASSERT(m_hasBeenReset);
     reset();
 
 #if ENABLE(OILPAN)
     // Oilpan: the frame host and document objects are
     // also garbage collected; cannot notify these
     // when removing event listeners.
     removeAllEventListenersInternal(DoNotBroadcastListenerRemoval);
 
     // Cleared when detaching document.
     ASSERT(!m_eventQueue);
 #else
     removeAllEventListenersInternal(DoBroadcastListenerRemoval);
 
     ASSERT(m_document->isStopped());
     clearDocument();
 #endif
 }
 
-const AtomicString& DOMWindow::interfaceName() const
+const AtomicString& LocalDOMWindow::interfaceName() const
 {
-    return EventTargetNames::DOMWindow;
+    return EventTargetNames::LocalDOMWindow;
 }
 
-ExecutionContext* DOMWindow::executionContext() const
+ExecutionContext* LocalDOMWindow::executionContext() const
 {
     return m_document.get();
 }
 
-DOMWindow* DOMWindow::toDOMWindow()
+LocalDOMWindow* LocalDOMWindow::toDOMWindow()
 {
     return this;
 }
 
-PassRefPtrWillBeRawPtr<MediaQueryList> DOMWindow::matchMedia(const String& media)
+PassRefPtrWillBeRawPtr<MediaQueryList> LocalDOMWindow::matchMedia(const String& media)
 {
     return document() ? document()->mediaQueryMatcher().matchMedia(media) : nullptr;
 }
 
-Page* DOMWindow::page()
+Page* LocalDOMWindow::page()
 {
     return frame() ? frame()->page() : 0;
 }
 
-void DOMWindow::frameDestroyed()
+void LocalDOMWindow::frameDestroyed()
 {
     FrameDestructionObserver::frameDestroyed();
     reset();
 }
 
-void DOMWindow::willDetachFrameHost()
+void LocalDOMWindow::willDetachFrameHost()
 {
     m_frame->host()->eventHandlerRegistry().didRemoveAllEventHandlers(*this);
     InspectorInstrumentation::frameWindowDiscarded(m_frame, this);
 }
 
-void DOMWindow::willDestroyDocumentInFrame()
+void LocalDOMWindow::willDestroyDocumentInFrame()
 {
     // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
-    // unregister themselves from the DOMWindow as a result of the call to willDestroyGlobalObjectInFrame.
+    // unregister themselves from the LocalDOMWindow as a result of the call to willDestroyGlobalObjectInFrame.
     Vector<DOMWindowProperty*> properties;
     copyToVector(m_properties, properties);
     for (size_t i = 0; i < properties.size(); ++i)
         properties[i]->willDestroyGlobalObjectInFrame();
 }
 
-void DOMWindow::willDetachDocumentFromFrame()
+void LocalDOMWindow::willDetachDocumentFromFrame()
 {
     // It is necessary to copy m_properties to a separate vector because the DOMWindowProperties may
-    // unregister themselves from the DOMWindow as a result of the call to willDetachGlobalObjectFromFrame.
+    // unregister themselves from the LocalDOMWindow as a result of the call to willDetachGlobalObjectFromFrame.
     Vector<DOMWindowProperty*> properties;
     copyToVector(m_properties, properties);
     for (size_t i = 0; i < properties.size(); ++i)
         properties[i]->willDetachGlobalObjectFromFrame();
 }
 
-void DOMWindow::registerProperty(DOMWindowProperty* property)
+void LocalDOMWindow::registerProperty(DOMWindowProperty* property)
 {
     m_properties.add(property);
 }
 
-void DOMWindow::unregisterProperty(DOMWindowProperty* property)
+void LocalDOMWindow::unregisterProperty(DOMWindowProperty* property)
 {
     m_properties.remove(property);
 }
 
-void DOMWindow::reset()
+void LocalDOMWindow::reset()
 {
     willDestroyDocumentInFrame();
     resetDOMWindowProperties();
 }
 
-void DOMWindow::resetDOMWindowProperties()
+void LocalDOMWindow::resetDOMWindowProperties()
 {
     m_properties.clear();
 
     m_screen = nullptr;
     m_history = nullptr;
     m_locationbar = nullptr;
     m_menubar = nullptr;
     m_personalbar = nullptr;
     m_scrollbars = nullptr;
     m_statusbar = nullptr;
     m_toolbar = nullptr;
     m_console = nullptr;
     m_navigator = nullptr;
     m_performance = nullptr;
     m_location = nullptr;
     m_media = nullptr;
     m_sessionStorage = nullptr;
     m_localStorage = nullptr;
     m_applicationCache = nullptr;
 #if ASSERT_ENABLED
     m_hasBeenReset = true;
 #endif
 }
 
-bool DOMWindow::isCurrentlyDisplayedInFrame() const
+bool LocalDOMWindow::isCurrentlyDisplayedInFrame() const
 {
     return m_frame && m_frame->domWindow() == this && m_frame->host();
 }
 
-int DOMWindow::orientation() const
+int LocalDOMWindow::orientation() const
 {
     ASSERT(RuntimeEnabledFeatures::orientationEventEnabled());
 
     if (!m_frame)
         return 0;
 
     int orientation = screenOrientationAngle(m_frame->view());
     // For backward compatibility, we want to return a value in the range of
     // [-90; 180] instead of [0; 360[ because window.orientation used to behave
     // like that in WebKit (this is a WebKit proprietary API).
     if (orientation == 270)
         return -90;
     return orientation;
 }
 
-Screen& DOMWindow::screen() const
+Screen& LocalDOMWindow::screen() const
 {
     if (!m_screen)
         m_screen = Screen::create(m_frame);
     return *m_screen;
 }
 
-History& DOMWindow::history() const
+History& LocalDOMWindow::history() const
 {
     if (!m_history)
         m_history = History::create(m_frame);
     return *m_history;
 }
 
-BarProp& DOMWindow::locationbar() const
+BarProp& LocalDOMWindow::locationbar() const
 {
     if (!m_locationbar)
         m_locationbar = BarProp::create(m_frame, BarProp::Locationbar);
     return *m_locationbar;
 }
 
-BarProp& DOMWindow::menubar() const
+BarProp& LocalDOMWindow::menubar() const
 {
     if (!m_menubar)
         m_menubar = BarProp::create(m_frame, BarProp::Menubar);
     return *m_menubar;
 }
 
-BarProp& DOMWindow::personalbar() const
+BarProp& LocalDOMWindow::personalbar() const
 {
     if (!m_personalbar)
         m_personalbar = BarProp::create(m_frame, BarProp::Personalbar);
     return *m_personalbar;
 }
 
-BarProp& DOMWindow::scrollbars() const
+BarProp& LocalDOMWindow::scrollbars() const
 {
     if (!m_scrollbars)
         m_scrollbars = BarProp::create(m_frame, BarProp::Scrollbars);
     return *m_scrollbars;
 }
 
-BarProp& DOMWindow::statusbar() const
+BarProp& LocalDOMWindow::statusbar() const
 {
     if (!m_statusbar)
         m_statusbar = BarProp::create(m_frame, BarProp::Statusbar);
     return *m_statusbar;
 }
 
-BarProp& DOMWindow::toolbar() const
+BarProp& LocalDOMWindow::toolbar() const
 {
     if (!m_toolbar)
         m_toolbar = BarProp::create(m_frame, BarProp::Toolbar);
     return *m_toolbar;
 }
 
-Console& DOMWindow::console() const
+Console& LocalDOMWindow::console() const
 {
     if (!m_console)
         m_console = Console::create(m_frame);
     return *m_console;
 }
 
-FrameConsole* DOMWindow::frameConsole() const
+FrameConsole* LocalDOMWindow::frameConsole() const
 {
     if (!isCurrentlyDisplayedInFrame())
         return 0;
     return &m_frame->console();
 }
 
-ApplicationCache* DOMWindow::applicationCache() const
+ApplicationCache* LocalDOMWindow::applicationCache() const
 {
     if (!isCurrentlyDisplayedInFrame())
         return 0;
     if (!m_applicationCache)
         m_applicationCache = ApplicationCache::create(m_frame);
     return m_applicationCache.get();
 }
 
-Navigator& DOMWindow::navigator() const
+Navigator& LocalDOMWindow::navigator() const
 {
     if (!m_navigator)
         m_navigator = Navigator::create(m_frame);
     return *m_navigator;
 }
 
-Performance& DOMWindow::performance() const
+Performance& LocalDOMWindow::performance() const
 {
     if (!m_performance)
         m_performance = Performance::create(m_frame);
     return *m_performance;
 }
 
-Location& DOMWindow::location() const
+Location& LocalDOMWindow::location() const
 {
     if (!m_location)
         m_location = Location::create(m_frame);
     return *m_location;
 }
 
-Storage* DOMWindow::sessionStorage(ExceptionState& exceptionState) const
+Storage* LocalDOMWindow::sessionStorage(ExceptionState& exceptionState) const
 {
     if (!isCurrentlyDisplayedInFrame())
         return 0;
 
     Document* document = this->document();
     if (!document)
         return 0;
 
     String accessDeniedMessage = "Access is denied for this document.";
     if (!document->securityOrigin()->canAccessLocalStorage()) {
@@ skipping 21 matching lines @@
     OwnPtrWillBeRawPtr<StorageArea> storageArea = page->sessionStorage()->storageArea(document->securityOrigin());
     if (!storageArea->canAccessStorage(m_frame)) {
         exceptionState.throwSecurityError(accessDeniedMessage);
         return 0;
     }
 
     m_sessionStorage = Storage::create(m_frame, storageArea.release());
     return m_sessionStorage.get();
 }
 
-Storage* DOMWindow::localStorage(ExceptionState& exceptionState) const
+Storage* LocalDOMWindow::localStorage(ExceptionState& exceptionState) const
 {
     if (!isCurrentlyDisplayedInFrame())
         return 0;
 
     Document* document = this->document();
     if (!document)
         return 0;
 
     String accessDeniedMessage = "Access is denied for this document.";
     if (!document->securityOrigin()->canAccessLocalStorage()) {
@@ skipping 22 matching lines @@
     OwnPtrWillBeRawPtr<StorageArea> storageArea = StorageNamespace::localStorageArea(document->securityOrigin());
     if (!storageArea->canAccessStorage(m_frame)) {
         exceptionState.throwSecurityError(accessDeniedMessage);
         return 0;
     }
 
     m_localStorage = Storage::create(m_frame, storageArea.release());
     return m_localStorage.get();
 }
 
-void DOMWindow::postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, const String& targetOrigin, DOMWindow* source, ExceptionState& exceptionState)
+void LocalDOMWindow::postMessage(PassRefPtr<SerializedScriptValue> message, const MessagePortArray* ports, const String& targetOrigin, LocalDOMWindow* source, ExceptionState& exceptionState)
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
 
     Document* sourceDocument = source->document();
 
     // Compute the target origin.  We need to do this synchronously in order
     // to generate the SyntaxError exception correctly.
     RefPtr<SecurityOrigin> target;
     if (targetOrigin == "/") {
@@ skipping 29 matching lines @@
     RefPtrWillBeRawPtr<ScriptCallStack> stackTrace = nullptr;
     if (InspectorInstrumentation::consoleAgentEnabled(sourceDocument))
         stackTrace = createScriptCallStack(ScriptCallStack::maxCallStackSizeToCapture, true);
 
     // Schedule the message.
     PostMessageTimer* timer = new PostMessageTimer(*this, message, sourceOrigin, source, channels.release(), target.get(), stackTrace.release(), UserGestureIndicator::currentToken());
     timer->startOneShot(0, FROM_HERE);
     timer->suspendIfNeeded();
 }
 
-void DOMWindow::postMessageTimerFired(PassOwnPtr<PostMessageTimer> t)
+void LocalDOMWindow::postMessageTimerFired(PassOwnPtr<PostMessageTimer> t)
 {
     OwnPtr<PostMessageTimer> timer(t);
 
     if (!isCurrentlyDisplayedInFrame())
         return;
 
     RefPtrWillBeRawPtr<MessageEvent> event = timer->event();
 
     // Give the embedder a chance to intercept this postMessage because this
-    // DOMWindow might be a proxy for another in browsers that support
+    // LocalDOMWindow might be a proxy for another in browsers that support
     // postMessage calls across WebKit instances.
     if (m_frame->loader().client()->willCheckAndDispatchMessageEvent(timer->targetOrigin(), event.get()))
         return;
 
     UserGestureIndicator gestureIndicator(timer->userGestureToken());
 
     event->entangleMessagePorts(document());
     dispatchMessageEventWithOriginCheck(timer->targetOrigin(), event, timer->stackTrace());
 }
 
-void DOMWindow::dispatchMessageEventWithOriginCheck(SecurityOrigin* intendedTargetOrigin, PassRefPtrWillBeRawPtr<Event> event, PassRefPtrWillBeRawPtr<ScriptCallStack> stackTrace)
+void LocalDOMWindow::dispatchMessageEventWithOriginCheck(SecurityOrigin* intendedTargetOrigin, PassRefPtrWillBeRawPtr<Event> event, PassRefPtrWillBeRawPtr<ScriptCallStack> stackTrace)
 {
     if (intendedTargetOrigin) {
         // Check target origin now since the target document may have changed since the timer was scheduled.
         if (!intendedTargetOrigin->isSameSchemeHostPort(document()->securityOrigin())) {
             String message = ExceptionMessages::failedToExecute("postMessage", "DOMWindow", "The target origin provided ('" + intendedTargetOrigin->toString() + "') does not match the recipient window's origin ('" + document()->securityOrigin()->toString() + "').");
             frameConsole()->addMessage(SecurityMessageSource, ErrorMessageLevel, message, stackTrace);
             return;
         }
     }
 
     dispatchEvent(event);
 }
 
-DOMSelection* DOMWindow::getSelection()
+DOMSelection* LocalDOMWindow::getSelection()
 {
     if (!isCurrentlyDisplayedInFrame() || !m_frame)
         return 0;
 
     return m_frame->document()->getSelection();
 }
 
-Element* DOMWindow::frameElement() const
+Element* LocalDOMWindow::frameElement() const
 {
     if (!m_frame)
         return 0;
 
     // The bindings security check should ensure we're same origin...
     ASSERT(!m_frame->owner() || m_frame->owner()->isLocal());
     return m_frame->deprecatedLocalOwner();
 }
 
-void DOMWindow::focus(ExecutionContext* context)
+void LocalDOMWindow::focus(ExecutionContext* context)
 {
     if (!m_frame)
         return;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     bool allowFocus = WindowFocusAllowedIndicator::windowFocusAllowed();
     if (context) {
         ASSERT(isMainThread());
         Document* activeDocument = toDocument(context);
         if (opener() && opener() != this && activeDocument->domWindow() == opener())
             allowFocus = true;
     }
 
     // If we're a top level window, bring the window to the front.
     if (m_frame->isMainFrame() && allowFocus)
         host->chrome().focus();
 
     if (!m_frame)
         return;
 
     m_frame->eventHandler().focusDocumentView();
 }
 
-void DOMWindow::blur()
+void LocalDOMWindow::blur()
 {
 }
 
-void DOMWindow::close(ExecutionContext* context)
+void LocalDOMWindow::close(ExecutionContext* context)
 {
     if (!m_frame || !m_frame->isMainFrame())
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
     if (context) {
         ASSERT(isMainThread());
@@ skipping 12 matching lines @@
         frameConsole()->addMessage(JSMessageSource, WarningMessageLevel, "Scripts may close only the windows that were opened by it.");
         return;
     }
 
     if (!m_frame->loader().shouldClose())
         return;
 
     page->chrome().closeWindowSoon();
 }
 
-void DOMWindow::print()
+void LocalDOMWindow::print()
 {
     if (!m_frame)
         return;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     if (m_frame->loader().state() != FrameStateComplete) {
         m_shouldPrintWhenFinishedLoading = true;
         return;
     }
     m_shouldPrintWhenFinishedLoading = false;
     host->chrome().print(m_frame);
 }
 
-void DOMWindow::stop()
+void LocalDOMWindow::stop()
 {
     if (!m_frame)
         return;
     m_frame->loader().stopAllLoaders();
 }
 
-void DOMWindow::alert(const String& message)
+void LocalDOMWindow::alert(const String& message)
 {
     if (!m_frame)
         return;
 
     m_frame->document()->updateRenderTreeIfNeeded();
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     host->chrome().runJavaScriptAlert(m_frame, message);
 }
 
-bool DOMWindow::confirm(const String& message)
+bool LocalDOMWindow::confirm(const String& message)
 {
     if (!m_frame)
         return false;
 
     m_frame->document()->updateRenderTreeIfNeeded();
 
     FrameHost* host = m_frame->host();
     if (!host)
         return false;
 
     return host->chrome().runJavaScriptConfirm(m_frame, message);
 }
 
-String DOMWindow::prompt(const String& message, const String& defaultValue)
+String LocalDOMWindow::prompt(const String& message, const String& defaultValue)
 {
     if (!m_frame)
         return String();
 
     m_frame->document()->updateRenderTreeIfNeeded();
 
     FrameHost* host = m_frame->host();
     if (!host)
         return String();
 
     String returnValue;
     if (host->chrome().runJavaScriptPrompt(m_frame, message, defaultValue, returnValue))
         return returnValue;
 
     return String();
 }
 
-bool DOMWindow::find(const String& string, bool caseSensitive, bool backwards, bool wrap, bool /*wholeWord*/, bool /*searchInFrames*/, bool /*showDialog*/) const
+bool LocalDOMWindow::find(const String& string, bool caseSensitive, bool backwards, bool wrap, bool /*wholeWord*/, bool /*searchInFrames*/, bool /*showDialog*/) const
 {
     if (!isCurrentlyDisplayedInFrame())
         return false;
 
     // |m_frame| can be destructed during |Editor::findString()| via
     // |Document::updateLayou()|, e.g. event handler removes a frame.
     RefPtr<LocalFrame> protectFrame(m_frame);
 
     // FIXME (13016): Support wholeWord, searchInFrames and showDialog
     return m_frame->editor().findString(string, !backwards, caseSensitive, wrap, false);
 }
 
-bool DOMWindow::offscreenBuffering() const
+bool LocalDOMWindow::offscreenBuffering() const
 {
     return true;
 }
 
-int DOMWindow::outerHeight() const
+int LocalDOMWindow::outerHeight() const
 {
     if (!m_frame)
         return 0;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return 0;
 
     if (host->settings().reportScreenSizeInPhysicalPixelsQuirk())
         return lroundf(host->chrome().windowRect().height() * host->deviceScaleFactor());
     return static_cast<int>(host->chrome().windowRect().height());
 }
 
-int DOMWindow::outerWidth() const
+int LocalDOMWindow::outerWidth() const
 {
     if (!m_frame)
         return 0;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return 0;
 
     if (host->settings().reportScreenSizeInPhysicalPixelsQuirk())
         return lroundf(host->chrome().windowRect().width() * host->deviceScaleFactor());
     return static_cast<int>(host->chrome().windowRect().width());
 }
 
-int DOMWindow::innerHeight() const
+int LocalDOMWindow::innerHeight() const
 {
     if (!m_frame)
         return 0;
 
     FrameView* view = m_frame->view();
     if (!view)
         return 0;
 
     // FIXME: This is potentially too much work. We really only need to know the dimensions of the parent frame's renderer.
     if (Frame* parent = m_frame->tree().parent()) {
         if (parent && parent->isLocalFrame())
             toLocalFrame(parent)->document()->updateLayoutIgnorePendingStylesheets();
     }
 
     return adjustForAbsoluteZoom(view->visibleContentRect(IncludeScrollbars).height(), m_frame->pageZoomFactor());
 }
 
-int DOMWindow::innerWidth() const
+int LocalDOMWindow::innerWidth() const
 {
     if (!m_frame)
         return 0;
 
     FrameView* view = m_frame->view();
     if (!view)
         return 0;
 
     // FIXME: This is potentially too much work. We really only need to know the dimensions of the parent frame's renderer.
     if (Frame* parent = m_frame->tree().parent()) {
         if (parent && parent->isLocalFrame())
             toLocalFrame(parent)->document()->updateLayoutIgnorePendingStylesheets();
     }
 
     return adjustForAbsoluteZoom(view->visibleContentRect(IncludeScrollbars).width(), m_frame->pageZoomFactor());
 }
 
-int DOMWindow::screenX() const
+int LocalDOMWindow::screenX() const
 {
     if (!m_frame)
         return 0;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return 0;
 
     if (host->settings().reportScreenSizeInPhysicalPixelsQuirk())
         return lroundf(host->chrome().windowRect().x() * host->deviceScaleFactor());
     return static_cast<int>(host->chrome().windowRect().x());
 }
 
-int DOMWindow::screenY() const
+int LocalDOMWindow::screenY() const
 {
     if (!m_frame)
         return 0;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return 0;
 
     if (host->settings().reportScreenSizeInPhysicalPixelsQuirk())
         return lroundf(host->chrome().windowRect().y() * host->deviceScaleFactor());
     return static_cast<int>(host->chrome().windowRect().y());
 }
 
-int DOMWindow::scrollX() const
+int LocalDOMWindow::scrollX() const
 {
     if (!m_frame)
         return 0;
 
     FrameView* view = m_frame->view();
     if (!view)
         return 0;
 
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
 
     return adjustForAbsoluteZoom(view->scrollX(), m_frame->pageZoomFactor());
 }
 
-int DOMWindow::scrollY() const
+int LocalDOMWindow::scrollY() const
 {
     if (!m_frame)
         return 0;
 
     FrameView* view = m_frame->view();
     if (!view)
         return 0;
 
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
 
     return adjustForAbsoluteZoom(view->scrollY(), m_frame->pageZoomFactor());
 }
 
-bool DOMWindow::closed() const
+bool LocalDOMWindow::closed() const
 {
     return !m_frame;
 }
 
-unsigned DOMWindow::length() const
+unsigned LocalDOMWindow::length() const
 {
     if (!isCurrentlyDisplayedInFrame())
         return 0;
 
     return m_frame->tree().scopedChildCount();
 }
 
-const AtomicString& DOMWindow::name() const
+const AtomicString& LocalDOMWindow::name() const
 {
     if (!isCurrentlyDisplayedInFrame())
         return nullAtom;
 
     return m_frame->tree().name();
 }
 
-void DOMWindow::setName(const AtomicString& name)
+void LocalDOMWindow::setName(const AtomicString& name)
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
 
     m_frame->tree().setName(name);
     ASSERT(m_frame->loader().client());
     m_frame->loader().client()->didChangeName(name);
 }
 
-void DOMWindow::setStatus(const String& string)
+void LocalDOMWindow::setStatus(const String& string)
 {
     m_status = string;
 
     if (!m_frame)
         return;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     ASSERT(m_frame->document()); // Client calls shouldn't be made when the frame is in inconsistent state.
     host->chrome().setStatusbarText(m_frame, m_status);
 }
 
-void DOMWindow::setDefaultStatus(const String& string)
+void LocalDOMWindow::setDefaultStatus(const String& string)
 {
     m_defaultStatus = string;
 
     if (!m_frame)
         return;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     ASSERT(m_frame->document()); // Client calls shouldn't be made when the frame is in inconsistent state.
     host->chrome().setStatusbarText(m_frame, m_defaultStatus);
 }
 
-DOMWindow* DOMWindow::self() const
+LocalDOMWindow* LocalDOMWindow::self() const
 {
     if (!m_frame)
         return 0;
 
     return m_frame->domWindow();
 }
 
-DOMWindow* DOMWindow::opener() const
+LocalDOMWindow* LocalDOMWindow::opener() const
 {
     if (!m_frame)
         return 0;
 
     LocalFrame* opener = m_frame->loader().opener();
     if (!opener)
         return 0;
 
     return opener->domWindow();
 }
 
-DOMWindow* DOMWindow::parent() const
+LocalDOMWindow* LocalDOMWindow::parent() const
 {
     if (!m_frame)
         return 0;
 
     Frame* parent = m_frame->tree().parent();
     if (parent)
         return parent->domWindow();
 
     return m_frame->domWindow();
 }
 
-DOMWindow* DOMWindow::top() const
+LocalDOMWindow* LocalDOMWindow::top() const
 {
     if (!m_frame)
         return 0;
 
     return m_frame->tree().top()->domWindow();
 }
 
-Document* DOMWindow::document() const
+Document* LocalDOMWindow::document() const
 {
     return m_document.get();
 }
 
-StyleMedia& DOMWindow::styleMedia() const
+StyleMedia& LocalDOMWindow::styleMedia() const
 {
     if (!m_media)
         m_media = StyleMedia::create(m_frame);
     return *m_media;
 }
 
-PassRefPtrWillBeRawPtr<CSSStyleDeclaration> DOMWindow::getComputedStyle(Element* elt, const String& pseudoElt) const
+PassRefPtrWillBeRawPtr<CSSStyleDeclaration> LocalDOMWindow::getComputedStyle(Element* elt, const String& pseudoElt) const
 {
     if (!elt)
         return nullptr;
 
     return CSSComputedStyleDeclaration::create(elt, false, pseudoElt);
 }
 
-PassRefPtrWillBeRawPtr<CSSRuleList> DOMWindow::getMatchedCSSRules(Element* element, const String& pseudoElement) const
+PassRefPtrWillBeRawPtr<CSSRuleList> LocalDOMWindow::getMatchedCSSRules(Element* element, const String& pseudoElement) const
 {
     if (!element)
         return nullptr;
 
     if (!isCurrentlyDisplayedInFrame())
         return nullptr;
 
     unsigned colonStart = pseudoElement[0] == ':' ? (pseudoElement[1] == ':' ? 2 : 1) : 0;
     CSSSelector::PseudoType pseudoType = CSSSelector::parsePseudoType(AtomicString(pseudoElement.substring(colonStart)));
     if (pseudoType == CSSSelector::PseudoUnknown && !pseudoElement.isEmpty())
         return nullptr;
 
     unsigned rulesToInclude = StyleResolver::AuthorCSSRules;
     PseudoId pseudoId = CSSSelector::pseudoId(pseudoType);
     return m_frame->document()->ensureStyleResolver().pseudoCSSRulesForElement(element, pseudoId, rulesToInclude);
 }
 
-PassRefPtrWillBeRawPtr<DOMPoint> DOMWindow::webkitConvertPointFromNodeToPage(Node* node, const DOMPoint* p) const
+PassRefPtrWillBeRawPtr<DOMPoint> LocalDOMWindow::webkitConvertPointFromNodeToPage(Node* node, const DOMPoint* p) const
 {
     if (!node || !p)
         return nullptr;
 
     if (!document())
         return nullptr;
 
     document()->updateLayoutIgnorePendingStylesheets();
 
     FloatPoint pagePoint(p->x(), p->y());
     pagePoint = node->convertToPage(pagePoint);
     return DOMPoint::create(pagePoint.x(), pagePoint.y());
 }
 
-PassRefPtrWillBeRawPtr<DOMPoint> DOMWindow::webkitConvertPointFromPageToNode(Node* node, const DOMPoint* p) const
+PassRefPtrWillBeRawPtr<DOMPoint> LocalDOMWindow::webkitConvertPointFromPageToNode(Node* node, const DOMPoint* p) const
 {
     if (!node || !p)
         return nullptr;
 
     if (!document())
         return nullptr;
 
     document()->updateLayoutIgnorePendingStylesheets();
 
     FloatPoint nodePoint(p->x(), p->y());
     nodePoint = node->convertFromPage(nodePoint);
     return DOMPoint::create(nodePoint.x(), nodePoint.y());
 }
 
-double DOMWindow::devicePixelRatio() const
+double LocalDOMWindow::devicePixelRatio() const
 {
     if (!m_frame)
         return 0.0;
 
     return m_frame->devicePixelRatio();
 }
 
 static bool scrollBehaviorFromScrollOptions(const Dictionary& scrollOptions, ScrollBehavior& scrollBehavior, ExceptionState& exceptionState)
 {
     String scrollBehaviorString;
     if (!scrollOptions.get("behavior", scrollBehaviorString)) {
         scrollBehavior = ScrollBehaviorAuto;
         return true;
     }
 
     if (ScrollableArea::scrollBehaviorFromString(scrollBehaviorString, scrollBehavior))
         return true;
 
     exceptionState.throwTypeError("The ScrollBehavior provided is invalid.");
     return false;
 }
 
-void DOMWindow::scrollBy(int x, int y) const
+void LocalDOMWindow::scrollBy(int x, int y) const
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
 
     document()->updateLayoutIgnorePendingStylesheets();
 
     FrameView* view = m_frame->view();
     if (!view)
         return;
 
     IntSize scaledOffset(x * m_frame->pageZoomFactor(), y * m_frame->pageZoomFactor());
     // FIXME: Use scrollBehavior to decide whether to scroll smoothly or instantly.
     view->scrollBy(scaledOffset);
 }
 
-void DOMWindow::scrollBy(int x, int y, const Dictionary& scrollOptions, ExceptionState &exceptionState) const
+void LocalDOMWindow::scrollBy(int x, int y, const Dictionary& scrollOptions, ExceptionState &exceptionState) const
 {
     ScrollBehavior scrollBehavior = ScrollBehaviorAuto;
     if (!scrollBehaviorFromScrollOptions(scrollOptions, scrollBehavior, exceptionState))
         return;
     scrollBy(x, y);
 }
 
-void DOMWindow::scrollTo(int x, int y) const
+void LocalDOMWindow::scrollTo(int x, int y) const
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
 
     document()->updateLayoutIgnorePendingStylesheets();
 
     RefPtr<FrameView> view = m_frame->view();
     if (!view)
         return;
 
     IntPoint layoutPos(x * m_frame->pageZoomFactor(), y * m_frame->pageZoomFactor());
     // FIXME: Use scrollBehavior to decide whether to scroll smoothly or instantly.
     view->setScrollPosition(layoutPos);
 }
 
-void DOMWindow::scrollTo(int x, int y, const Dictionary& scrollOptions, ExceptionState& exceptionState) const
+void LocalDOMWindow::scrollTo(int x, int y, const Dictionary& scrollOptions, ExceptionState& exceptionState) const
 {
     ScrollBehavior scrollBehavior = ScrollBehaviorAuto;
     if (!scrollBehaviorFromScrollOptions(scrollOptions, scrollBehavior, exceptionState))
         return;
     scrollTo(x, y);
 }
 
-void DOMWindow::moveBy(float x, float y) const
+void LocalDOMWindow::moveBy(float x, float y) const
 {
     if (!m_frame || !m_frame->isMainFrame())
         return;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     FloatRect windowRect = host->chrome().windowRect();
     windowRect.move(x, y);
     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
     host->chrome().setWindowRect(adjustWindowRect(*m_frame, windowRect));
 }
 
-void DOMWindow::moveTo(float x, float y) const
+void LocalDOMWindow::moveTo(float x, float y) const
 {
     if (!m_frame || !m_frame->isMainFrame())
         return;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     FloatRect windowRect = host->chrome().windowRect();
     windowRect.setLocation(FloatPoint(x, y));
     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
     host->chrome().setWindowRect(adjustWindowRect(*m_frame, windowRect));
 }
 
-void DOMWindow::resizeBy(float x, float y) const
+void LocalDOMWindow::resizeBy(float x, float y) const
 {
     if (!m_frame || !m_frame->isMainFrame())
         return;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     FloatRect fr = host->chrome().windowRect();
     FloatSize dest = fr.size() + FloatSize(x, y);
     FloatRect update(fr.location(), dest);
     host->chrome().setWindowRect(adjustWindowRect(*m_frame, update));
 }
 
-void DOMWindow::resizeTo(float width, float height) const
+void LocalDOMWindow::resizeTo(float width, float height) const
 {
     if (!m_frame || !m_frame->isMainFrame())
         return;
 
     FrameHost* host = m_frame->host();
     if (!host)
         return;
 
     FloatRect fr = host->chrome().windowRect();
     FloatSize dest = FloatSize(width, height);
     FloatRect update(fr.location(), dest);
     host->chrome().setWindowRect(adjustWindowRect(*m_frame, update));
 }
 
-int DOMWindow::requestAnimationFrame(PassOwnPtr<RequestAnimationFrameCallback> callback)
+int LocalDOMWindow::requestAnimationFrame(PassOwnPtr<RequestAnimationFrameCallback> callback)
 {
     callback->m_useLegacyTimeBase = false;
     if (Document* d = document())
         return d->requestAnimationFrame(callback);
     return 0;
 }
 
-int DOMWindow::webkitRequestAnimationFrame(PassOwnPtr<RequestAnimationFrameCallback> callback)
+int LocalDOMWindow::webkitRequestAnimationFrame(PassOwnPtr<RequestAnimationFrameCallback> callback)
 {
     callback->m_useLegacyTimeBase = true;
     if (Document* d = document())
         return d->requestAnimationFrame(callback);
     return 0;
 }
 
-void DOMWindow::cancelAnimationFrame(int id)
+void LocalDOMWindow::cancelAnimationFrame(int id)
 {
     if (Document* d = document())
         d->cancelAnimationFrame(id);
 }
 
-DOMWindowCSS& DOMWindow::css() const
+DOMWindowCSS& LocalDOMWindow::css() const
 {
     if (!m_css)
         m_css = DOMWindowCSS::create();
     return *m_css;
 }
 
-static void didAddStorageEventListener(DOMWindow* window)
+static void didAddStorageEventListener(LocalDOMWindow* window)
 {
     // Creating these WebCore::Storage objects informs the system that we'd like to receive
     // notifications about storage events that might be triggered in other processes. Rather
     // than subscribe to these notifications explicitly, we subscribe to them implicitly to
     // simplify the work done by the system.
     window->localStorage(IGNORE_EXCEPTION);
     window->sessionStorage(IGNORE_EXCEPTION);
 }
 
-bool DOMWindow::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
+bool LocalDOMWindow::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
 {
     if (!EventTarget::addEventListener(eventType, listener, useCapture))
         return false;
 
     if (m_frame && m_frame->host())
         m_frame->host()->eventHandlerRegistry().didAddEventHandler(*this, eventType);
 
     if (Document* document = this->document()) {
         document->addListenerTypeIfNeeded(eventType);
         if (isTouchEventType(eventType))
@@ skipping 16 matching lines @@
             addBeforeUnloadEventListener(this);
         } else {
             // Subframes return false from allowsBeforeUnloadListeners.
             UseCounter::count(document(), UseCounter::SubFrameBeforeUnloadRegistered);
         }
     }
 
     return true;
 }
 
-bool DOMWindow::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
+bool LocalDOMWindow::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
 {
     if (!EventTarget::removeEventListener(eventType, listener, useCapture))
         return false;
 
     if (m_frame && m_frame->host())
         m_frame->host()->eventHandlerRegistry().didRemoveEventHandler(*this, eventType);
 
     if (Document* document = this->document()) {
         if (isTouchEventType(eventType))
             document->didRemoveTouchEventHandler(document);
     }
 
     lifecycleNotifier().notifyRemoveEventListener(this, eventType);
 
     if (eventType == EventTypeNames::unload) {
         removeUnloadEventListener(this);
     } else if (eventType == EventTypeNames::beforeunload && allowsBeforeUnloadListeners(this)) {
         removeBeforeUnloadEventListener(this);
     }
 
     return true;
 }
 
-void DOMWindow::dispatchLoadEvent()
+void LocalDOMWindow::dispatchLoadEvent()
 {
     RefPtrWillBeRawPtr<Event> loadEvent(Event::create(EventTypeNames::load));
     if (m_frame && m_frame->loader().documentLoader() && !m_frame->loader().documentLoader()->timing()->loadEventStart()) {
         // The DocumentLoader (and thus its DocumentLoadTiming) might get destroyed while dispatching
         // the event, so protect it to prevent writing the end time into freed memory.
         RefPtr<DocumentLoader> documentLoader = m_frame->loader().documentLoader();
         DocumentLoadTiming* timing = documentLoader->timing();
         timing->markLoadEventStart();
         dispatchEvent(loadEvent, document());
         timing->markLoadEventEnd();
     } else
         dispatchEvent(loadEvent, document());
 
     // For load events, send a separate load event to the enclosing frame only.
     // This is a DOM extension and is independent of bubbling/capturing rules of
     // the DOM.
     FrameOwner* owner = m_frame ? m_frame->owner() : 0;
     if (owner)
         owner->dispatchLoad();
 
     TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "MarkLoad", "data", InspectorMarkLoadEvent::data(frame()));
     // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
     InspectorInstrumentation::loadEventFired(frame());
 }
 
-bool DOMWindow::dispatchEvent(PassRefPtrWillBeRawPtr<Event> prpEvent, PassRefPtrWillBeRawPtr<EventTarget> prpTarget)
+bool LocalDOMWindow::dispatchEvent(PassRefPtrWillBeRawPtr<Event> prpEvent, PassRefPtrWillBeRawPtr<EventTarget> prpTarget)
 {
     ASSERT(!NoEventDispatchAssertion::isEventDispatchForbidden());
 
     RefPtrWillBeRawPtr<EventTarget> protect(this);
     RefPtrWillBeRawPtr<Event> event = prpEvent;
 
     event->setTarget(prpTarget ? prpTarget : this);
     event->setCurrentTarget(this);
     event->setEventPhase(Event::AT_TARGET);
 
     TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "EventDispatch", "type", event->type().ascii());
     // FIXME(361045): remove InspectorInstrumentation calls once DevTools Timeline migrates to tracing.
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willDispatchEventOnWindow(frame(), *event, this);
 
     bool result = fireEventListeners(event.get());
 
     InspectorInstrumentation::didDispatchEventOnWindow(cookie);
 
     return result;
 }
 
-void DOMWindow::removeAllEventListenersInternal(BroadcastListenerRemoval mode)
+void LocalDOMWindow::removeAllEventListenersInternal(BroadcastListenerRemoval mode)
 {
     EventTarget::removeAllEventListeners();
 
     lifecycleNotifier().notifyRemoveAllEventListeners(this);
 
     if (mode == DoBroadcastListenerRemoval) {
         if (m_frame && m_frame->host())
             m_frame->host()->eventHandlerRegistry().didRemoveAllEventHandlers(*this);
 
         if (Document* document = this->document())
             document->didClearTouchEventHandlers(document);
     }
 
     removeAllUnloadEventListeners(this);
     removeAllBeforeUnloadEventListeners(this);
 }
 
-void DOMWindow::removeAllEventListeners()
+void LocalDOMWindow::removeAllEventListeners()
 {
     removeAllEventListenersInternal(DoBroadcastListenerRemoval);
 }
 
-void DOMWindow::finishedLoading()
+void LocalDOMWindow::finishedLoading()
 {
     if (m_shouldPrintWhenFinishedLoading) {
         m_shouldPrintWhenFinishedLoading = false;
         print();
     }
 }
 
-void DOMWindow::setLocation(const String& urlString, DOMWindow* callingWindow, DOMWindow* enteredWindow, SetLocationLocking locking)
+void LocalDOMWindow::setLocation(const String& urlString, LocalDOMWindow* callingWindow, LocalDOMWindow* enteredWindow, SetLocationLocking locking)
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
 
     Document* activeDocument = callingWindow->document();
     if (!activeDocument)
         return;
 
     ASSERT(m_frame);
     if (!activeDocument->canNavigate(*m_frame))
@@ skipping 10 matching lines @@
     if (isInsecureScriptAccess(*callingWindow, completedURL))
         return;
 
     // We want a new history item if we are processing a user gesture.
     m_frame->navigationScheduler().scheduleLocationChange(activeDocument,
         // FIXME: What if activeDocument()->frame() is 0?
         completedURL, Referrer(activeDocument->outgoingReferrer(), activeDocument->referrerPolicy()),
         locking != LockHistoryBasedOnGestureState);
 }
 
-void DOMWindow::printErrorMessage(const String& message)
+void LocalDOMWindow::printErrorMessage(const String& message)
 {
     if (message.isEmpty())
         return;
 
     frameConsole()->addMessage(JSMessageSource, ErrorMessageLevel, message);
 }
 
 // FIXME: Once we're throwing exceptions for cross-origin access violations, we will always sanitize the target
 // frame details, so we can safely combine 'crossDomainAccessErrorMessage' with this method after considering
 // exactly which details may be exposed to JavaScript.
 //
 // http://crbug.com/17325
-String DOMWindow::sanitizedCrossDomainAccessErrorMessage(DOMWindow* callingWindow)
+String LocalDOMWindow::sanitizedCrossDomainAccessErrorMessage(LocalDOMWindow* callingWindow)
 {
     if (!callingWindow || !callingWindow->document())
         return String();
 
     const KURL& callingWindowURL = callingWindow->document()->url();
     if (callingWindowURL.isNull())
         return String();
 
     ASSERT(!callingWindow->document()->securityOrigin()->canAccess(document()->securityOrigin()));
 
     SecurityOrigin* activeOrigin = callingWindow->document()->securityOrigin();
     String message = "Blocked a frame with origin \"" + activeOrigin->toString() + "\" from accessing a cross-origin frame.";
 
     // FIXME: Evaluate which details from 'crossDomainAccessErrorMessage' may safely be reported to JavaScript.
 
     return message;
 }
 
-String DOMWindow::crossDomainAccessErrorMessage(DOMWindow* callingWindow)
+String LocalDOMWindow::crossDomainAccessErrorMessage(LocalDOMWindow* callingWindow)
 {
     if (!callingWindow || !callingWindow->document())
         return String();
 
     const KURL& callingWindowURL = callingWindow->document()->url();
     if (callingWindowURL.isNull())
         return String();
 
     ASSERT(!callingWindow->document()->securityOrigin()->canAccess(document()->securityOrigin()));
 
@@ skipping 23 matching lines @@
         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.";
     if (activeOrigin->domainWasSetInDOM())
         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.";
     if (targetOrigin->domainWasSetInDOM())
         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.";
 
     // Default.
     return message + "Protocols, domains, and ports must match.";
 }
 
-bool DOMWindow::isInsecureScriptAccess(DOMWindow& callingWindow, const String& urlString)
+bool LocalDOMWindow::isInsecureScriptAccess(LocalDOMWindow& callingWindow, const String& urlString)
 {
     if (!protocolIsJavaScript(urlString))
         return false;
 
-    // If this DOMWindow isn't currently active in the LocalFrame, then there's no
+    // If this LocalDOMWindow isn't currently active in the LocalFrame, then there's no
     // way we should allow the access.
-    // FIXME: Remove this check if we're able to disconnect DOMWindow from
+    // FIXME: Remove this check if we're able to disconnect LocalDOMWindow from
     // LocalFrame on navigation: https://bugs.webkit.org/show_bug.cgi?id=62054
     if (isCurrentlyDisplayedInFrame()) {
         // FIXME: Is there some way to eliminate the need for a separate "callingWindow == this" check?
         if (&callingWindow == this)
             return false;
 
         // FIXME: The name canAccess seems to be a roundabout way to ask "can execute script".
         // Can we name the SecurityOrigin function better to make this more clear?
         if (callingWindow.document()->securityOrigin()->canAccess(document()->securityOrigin()))
             return false;
     }
 
     printErrorMessage(crossDomainAccessErrorMessage(&callingWindow));
     return true;
 }
 
-PassRefPtrWillBeRawPtr<DOMWindow> DOMWindow::open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
-    DOMWindow* callingWindow, DOMWindow* enteredWindow)
+PassRefPtrWillBeRawPtr<LocalDOMWindow> LocalDOMWindow::open(const String& urlString, const AtomicString& frameName, const String& windowFeaturesString,
+    LocalDOMWindow* callingWindow, LocalDOMWindow* enteredWindow)
 {
     if (!isCurrentlyDisplayedInFrame())
         return nullptr;
     Document* activeDocument = callingWindow->document();
     if (!activeDocument)
         return nullptr;
     LocalFrame* firstFrame = enteredWindow->frame();
     if (!firstFrame)
         return nullptr;
 
@@ skipping 36 matching lines @@
             Referrer(firstFrame->document()->outgoingReferrer(), firstFrame->document()->referrerPolicy()),
             false);
         return targetFrame->domWindow();
     }
 
     WindowFeatures windowFeatures(windowFeaturesString);
     LocalFrame* result = createWindow(urlString, frameName, windowFeatures, *callingWindow, *firstFrame, *m_frame);
     return result ? result->domWindow() : 0;
 }
 
-void DOMWindow::showModalDialog(const String& urlString, const String& dialogFeaturesString,
-    DOMWindow* callingWindow, DOMWindow* enteredWindow, PrepareDialogFunction function, void* functionContext)
+void LocalDOMWindow::showModalDialog(const String& urlString, const String& dialogFeaturesString,
+    LocalDOMWindow* callingWindow, LocalDOMWindow* enteredWindow, PrepareDialogFunction function, void* functionContext)
 {
     if (!isCurrentlyDisplayedInFrame())
         return;
     LocalFrame* activeFrame = callingWindow->frame();
     if (!activeFrame)
         return;
     LocalFrame* firstFrame = enteredWindow->frame();
     if (!firstFrame)
         return;
 
     if (!canShowModalDialogNow(m_frame) || !enteredWindow->allowPopUp())
         return;
 
     UseCounter::countDeprecation(this, UseCounter::ShowModalDialog);
 
     WindowFeatures windowFeatures(dialogFeaturesString, screenAvailableRect(m_frame->view()));
     LocalFrame* dialogFrame = createWindow(urlString, emptyAtom, windowFeatures,
         *callingWindow, *firstFrame, *m_frame, function, functionContext);
     if (!dialogFrame)
         return;
     UserGestureIndicatorDisabler disabler;
     dialogFrame->host()->chrome().runModal();
 }
 
-DOMWindow* DOMWindow::anonymousIndexedGetter(uint32_t index)
+LocalDOMWindow* LocalDOMWindow::anonymousIndexedGetter(uint32_t index)
 {
     LocalFrame* frame = this->frame();
     if (!frame)
         return 0;
 
     Frame* child = frame->tree().scopedChild(index);
     if (child)
         return child->domWindow();
 
     return 0;
 }
 
-DOMWindowLifecycleNotifier& DOMWindow::lifecycleNotifier()
+DOMWindowLifecycleNotifier& LocalDOMWindow::lifecycleNotifier()
 {
-    return static_cast<DOMWindowLifecycleNotifier&>(LifecycleContext<DOMWindow>::lifecycleNotifier());
+    return static_cast<DOMWindowLifecycleNotifier&>(LifecycleContext<LocalDOMWindow>::lifecycleNotifier());
 }
 
-PassOwnPtr<LifecycleNotifier<DOMWindow> > DOMWindow::createLifecycleNotifier()
+PassOwnPtr<LifecycleNotifier<LocalDOMWindow> > LocalDOMWindow::createLifecycleNotifier()
 {
     return DOMWindowLifecycleNotifier::create(this);
 }
 
-void DOMWindow::trace(Visitor* visitor)
+void LocalDOMWindow::trace(Visitor* visitor)
 {
     visitor->trace(m_document);
     visitor->trace(m_screen);
     visitor->trace(m_history);
     visitor->trace(m_locationbar);
     visitor->trace(m_menubar);
     visitor->trace(m_personalbar);
     visitor->trace(m_scrollbars);
     visitor->trace(m_statusbar);
     visitor->trace(m_toolbar);
     visitor->trace(m_console);
     visitor->trace(m_navigator);
     visitor->trace(m_location);
     visitor->trace(m_media);
     visitor->trace(m_sessionStorage);
     visitor->trace(m_localStorage);
     visitor->trace(m_applicationCache);
     visitor->trace(m_performance);
     visitor->trace(m_css);
     visitor->trace(m_eventQueue);
-    WillBeHeapSupplementable<DOMWindow>::trace(visitor);
+    WillBeHeapSupplementable<LocalDOMWindow>::trace(visitor);
     EventTargetWithInlineData::trace(visitor);
 }
 
 } // namespace WebCore