Rename WebFrameImpl to WebLocalFrameImpl.

Source/web/WebLocalFrameImpl.cpp

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 48 matching lines @@
 //
 // When frame content is replaced, all subframes are destroyed. This happens
 // in FrameLoader::detachFromParent for each subframe in a pre-order depth-first
 // traversal. Note that child node order may not match DOM node order!
 // detachFromParent() calls FrameLoaderClient::detachedFromParent(), which calls
 // WebFrame::frameDetached(). This triggers WebFrame to clear its reference to
 // LocalFrame, and also notifies the embedder via WebFrameClient that the frame is
 // detached. Most embedders will invoke close() on the WebFrame at this point,
 // triggering its deletion unless something else is still retaining a reference.
 //
-// Thie client is expected to be set whenever the WebFrameImpl is attached to
+// Thie client is expected to be set whenever the WebLocalFrameImpl is attached to
 // the DOM.
 
 #include "config.h"
-#include "WebFrameImpl.h"
+#include "WebLocalFrameImpl.h"
 
-#include <algorithm>
 #include "AssociatedURLLoader.h"
 #include "CompositionUnderlineVectorBuilder.h"
 #include "EventListenerWrapper.h"
 #include "FindInPageCoordinates.h"
 #include "HTMLNames.h"
 #include "PageOverlay.h"
 #include "SharedWorkerRepositoryClientImpl.h"
 #include "TextFinder.h"
 #include "WebConsoleMessage.h"
 #include "WebDOMEvent.h"
@@ skipping 38 matching lines @@
 #include "core/editing/InputMethodController.h"
 #include "core/editing/PlainTextRange.h"
 #include "core/editing/SpellChecker.h"
 #include "core/editing/TextAffinity.h"
 #include "core/editing/TextIterator.h"
 #include "core/editing/htmlediting.h"
 #include "core/editing/markup.h"
 #include "core/frame/Console.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/FrameView.h"
+#include "core/frame/Settings.h"
 #include "core/html/HTMLCollection.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLHeadElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/html/PluginDocument.h"
 #include "core/inspector/InspectorController.h"
 #include "core/inspector/ScriptCallStack.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/HistoryItem.h"
 #include "core/loader/SubstituteData.h"
 #include "core/page/Chrome.h"
 #include "core/page/EventHandler.h"
 #include "core/page/FocusController.h"
 #include "core/page/FrameTree.h"
 #include "core/page/Page.h"
 #include "core/page/PrintContext.h"
-#include "core/frame/Settings.h"
 #include "core/rendering/HitTestResult.h"
 #include "core/rendering/RenderBox.h"
 #include "core/rendering/RenderFrame.h"
 #include "core/rendering/RenderLayer.h"
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderTreeAsText.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/style/StyleInheritedData.h"
 #include "core/timing/Performance.h"
 #include "modules/notifications/NotificationController.h"
 #include "platform/TraceEvent.h"
 #include "platform/UserGestureIndicator.h"
 #include "platform/clipboard/ClipboardUtilities.h"
 #include "platform/fonts/FontCache.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/GraphicsLayerClient.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/heap/Handle.h"
 #include "platform/network/ResourceRequest.h"
+#include "platform/scroll/ScrollTypes.h"
 #include "platform/scroll/ScrollbarTheme.h"
-#include "platform/scroll/ScrollTypes.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SchemeRegistry.h"
 #include "platform/weborigin/SecurityPolicy.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebFloatPoint.h"
 #include "public/platform/WebFloatRect.h"
 #include "public/platform/WebLayer.h"
 #include "public/platform/WebPoint.h"
 #include "public/platform/WebRect.h"
 #include "public/platform/WebSize.h"
 #include "public/platform/WebURLError.h"
 #include "public/platform/WebVector.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HashMap.h"
+#include <algorithm>
 
 using namespace WebCore;
 
 namespace blink {
 
 static int frameCount = 0;
 
 // Key for a StatsCounter tracking how many WebFrames are active.
 static const char webFrameActiveCount[] = "WebFrameActiveCount";
 
@@ skipping 51 matching lines @@
         if (output.length() >= maxChars - frameSeparatorLength)
             return;
 
         output.append(frameSeparator, frameSeparatorLength);
         frameContentAsPlainText(maxChars, curChild, output);
         if (output.length() >= maxChars)
             return; // Filled up the buffer.
     }
 }
 
-WebPluginContainerImpl* WebFrameImpl::pluginContainerFromFrame(LocalFrame* frame)
+WebPluginContainerImpl* WebLocalFrameImpl::pluginContainerFromFrame(LocalFrame* frame)
 {
     if (!frame)
         return 0;
     if (!frame->document() || !frame->document()->isPluginDocument())
         return 0;
     PluginDocument* pluginDocument = toPluginDocument(frame->document());
     return toWebPluginContainerImpl(pluginDocument->pluginWidget());
 }
 
-WebPluginContainerImpl* WebFrameImpl::pluginContainerFromNode(WebCore::LocalFrame* frame, const WebNode& node)
+WebPluginContainerImpl* WebLocalFrameImpl::pluginContainerFromNode(WebCore::LocalFrame* frame, const WebNode& node)
 {
     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame);
     if (pluginContainer)
         return pluginContainer;
     return toWebPluginContainerImpl(node.pluginContainer());
 }
 
 // Simple class to override some of PrintContext behavior. Some of the methods
 // made virtual so that they can be overridden by ChromePluginPrintContext.
 class ChromePrintContext : public PrintContext {
@@ skipping 178 matching lines @@
 WebLocalFrame* WebLocalFrame::frameForCurrentContext()
 {
     v8::Handle<v8::Context> context = v8::Isolate::GetCurrent()->GetCurrentContext();
     if (context.IsEmpty())
         return 0;
     return frameForContext(context);
 }
 
 WebLocalFrame* WebLocalFrame::frameForContext(v8::Handle<v8::Context> context)
 {
-   return WebFrameImpl::fromFrame(toFrameIfNotDetached(context));
+    return WebLocalFrameImpl::fromFrame(toFrameIfNotDetached(context));
 }
 
 WebLocalFrame* WebLocalFrame::fromFrameOwnerElement(const WebElement& element)
 {
-    return WebFrameImpl::fromFrameOwnerElement(PassRefPtr<Element>(element).get());
+    return WebLocalFrameImpl::fromFrameOwnerElement(PassRefPtr<Element>(element).get());
 }
 
-void WebFrameImpl::close()
+bool WebLocalFrameImpl::isWebLocalFrame() const
+{
+    return true;
+}
+
+WebLocalFrame* WebLocalFrameImpl::toWebLocalFrame()
+{
+    return this;
+}
+
+bool WebLocalFrameImpl::isWebRemoteFrame() const
+{
+    return false;
+}
+
+WebRemoteFrame* WebLocalFrameImpl::toWebRemoteFrame()
+{
+    ASSERT_NOT_REACHED();
+    return 0;
+}
+
+void WebLocalFrameImpl::close()
 {
     m_client = 0;
     deref(); // Balances ref() acquired in WebFrame::create
 }
 
-WebString WebFrameImpl::uniqueName() const
+WebString WebLocalFrameImpl::uniqueName() const
 {
     return frame()->tree().uniqueName();
 }
 
-WebString WebFrameImpl::assignedName() const
+WebString WebLocalFrameImpl::assignedName() const
 {
     return frame()->tree().name();
 }
 
-void WebFrameImpl::setName(const WebString& name)
+void WebLocalFrameImpl::setName(const WebString& name)
 {
     frame()->tree().setName(name);
 }
 
-WebVector<WebIconURL> WebFrameImpl::iconURLs(int iconTypesMask) const
+WebVector<WebIconURL> WebLocalFrameImpl::iconURLs(int iconTypesMask) const
 {
     // The URL to the icon may be in the header. As such, only
     // ask the loader for the icon if it's finished loading.
     if (frame()->loader().state() == FrameStateComplete)
         return frame()->document()->iconURLs(iconTypesMask);
     return WebVector<WebIconURL>();
 }
 
-void WebFrameImpl::setIsRemote(bool isRemote)
+void WebLocalFrameImpl::setIsRemote(bool isRemote)
 {
     m_isRemote = isRemote;
     if (isRemote)
         client()->initializeChildFrame(frame()->view()->frameRect(), frame()->view()->visibleContentScaleFactor());
 }
 
-void WebFrameImpl::setRemoteWebLayer(WebLayer* webLayer)
+void WebLocalFrameImpl::setRemoteWebLayer(WebLayer* webLayer)
 {
     if (!frame())
         return;
 
     if (frame()->remotePlatformLayer())
         GraphicsLayer::unregisterContentsLayer(frame()->remotePlatformLayer());
     if (webLayer)
         GraphicsLayer::registerContentsLayer(webLayer);
     frame()->setRemotePlatformLayer(webLayer);
     frame()->ownerElement()->scheduleLayerUpdate();
 }
 
-void WebFrameImpl::setPermissionClient(WebPermissionClient* permissionClient)
+void WebLocalFrameImpl::setPermissionClient(WebPermissionClient* permissionClient)
 {
     m_permissionClient = permissionClient;
 }
 
-void WebFrameImpl::setSharedWorkerRepositoryClient(WebSharedWorkerRepositoryClient* client)
+void WebLocalFrameImpl::setSharedWorkerRepositoryClient(WebSharedWorkerRepositoryClient* client)
 {
     m_sharedWorkerRepositoryClient = SharedWorkerRepositoryClientImpl::create(client);
 }
 
-WebSize WebFrameImpl::scrollOffset() const
+WebSize WebLocalFrameImpl::scrollOffset() const
 {
     FrameView* view = frameView();
     if (!view)
         return WebSize();
     return view->scrollOffset();
 }
 
-WebSize WebFrameImpl::minimumScrollOffset() const
+WebSize WebLocalFrameImpl::minimumScrollOffset() const
 {
     FrameView* view = frameView();
     if (!view)
         return WebSize();
     return toIntSize(view->minimumScrollPosition());
 }
 
-WebSize WebFrameImpl::maximumScrollOffset() const
+WebSize WebLocalFrameImpl::maximumScrollOffset() const
 {
     FrameView* view = frameView();
     if (!view)
         return WebSize();
     return toIntSize(view->maximumScrollPosition());
 }
 
-void WebFrameImpl::setScrollOffset(const WebSize& offset)
+void WebLocalFrameImpl::setScrollOffset(const WebSize& offset)
 {
     if (FrameView* view = frameView())
         view->setScrollOffset(IntPoint(offset.width, offset.height));
 }
 
-WebSize WebFrameImpl::contentsSize() const
+WebSize WebLocalFrameImpl::contentsSize() const
 {
     return frame()->view()->contentsSize();
 }
 
-bool WebFrameImpl::hasVisibleContent() const
+bool WebLocalFrameImpl::hasVisibleContent() const
 {
     return frame()->view()->visibleWidth() > 0 && frame()->view()->visibleHeight() > 0;
 }
 
-WebRect WebFrameImpl::visibleContentRect() const
+WebRect WebLocalFrameImpl::visibleContentRect() const
 {
     return frame()->view()->visibleContentRect();
 }
 
-bool WebFrameImpl::hasHorizontalScrollbar() const
+bool WebLocalFrameImpl::hasHorizontalScrollbar() const
 {
     return frame() && frame()->view() && frame()->view()->horizontalScrollbar();
 }
 
-bool WebFrameImpl::hasVerticalScrollbar() const
+bool WebLocalFrameImpl::hasVerticalScrollbar() const
 {
     return frame() && frame()->view() && frame()->view()->verticalScrollbar();
 }
 
-WebView* WebFrameImpl::view() const
+WebView* WebLocalFrameImpl::view() const
 {
     return viewImpl();
 }
 
-WebFrame* WebFrameImpl::opener() const
+WebFrame* WebLocalFrameImpl::opener() const
 {
     return m_opener;
 }
 
-void WebFrameImpl::setOpener(WebFrame* opener)
+void WebLocalFrameImpl::setOpener(WebFrame* opener)
 {
-    WebFrameImpl* openerImpl = toWebFrameImpl(opener);
+    WebLocalFrameImpl* openerImpl = toWebLocalFrameImpl(opener);
     if (m_opener && !openerImpl && m_client)
         m_client->didDisownOpener(this);
 
     if (m_opener)
         m_opener->m_openedFrames.remove(this);
     if (openerImpl)
         openerImpl->m_openedFrames.add(this);
     m_opener = openerImpl;
 
     ASSERT(m_frame);
     if (m_frame && m_frame->document())
         m_frame->document()->initSecurityContext();
 }
 
-void WebFrameImpl::appendChild(WebFrame* child)
+void WebLocalFrameImpl::appendChild(WebFrame* child)
 {
     // FIXME: Original code asserts that the frames have the same Page. We
     // should add an equivalent check... figure out what.
-    WebFrameImpl* childImpl = toWebFrameImpl(child);
+    WebLocalFrameImpl* childImpl = toWebLocalFrameImpl(child);
     childImpl->m_parent = this;
-    WebFrameImpl* oldLast = m_lastChild;
+    WebLocalFrameImpl* oldLast = m_lastChild;
     m_lastChild = childImpl;
 
     if (oldLast) {
         childImpl->m_previousSibling = oldLast;
         oldLast->m_nextSibling = childImpl;
     } else {
         m_firstChild = childImpl;
     }
     // FIXME: Not sure if this is a legitimate assert.
     ASSERT(frame());
     frame()->tree().invalidateScopedChildCount();
 }
 
-void WebFrameImpl::removeChild(WebFrame* child)
+void WebLocalFrameImpl::removeChild(WebFrame* child)
 {
-    WebFrameImpl* childImpl = toWebFrameImpl(child);
+    WebLocalFrameImpl* childImpl = toWebLocalFrameImpl(child);
     childImpl->m_parent = 0;
 
     if (m_firstChild == childImpl)
         m_firstChild = childImpl->m_nextSibling;
     else
         childImpl->m_previousSibling->m_nextSibling = childImpl->m_nextSibling;
 
     if (m_lastChild == childImpl)
         m_lastChild = childImpl->m_previousSibling;
     else
         childImpl->m_nextSibling->m_previousSibling = childImpl->m_previousSibling;
 
     childImpl->m_previousSibling = childImpl->m_nextSibling = 0;
     // FIXME: Not sure if this is a legitimate assert.
     ASSERT(frame());
     frame()->tree().invalidateScopedChildCount();
 }
 
-WebFrame* WebFrameImpl::parent() const
+WebFrame* WebLocalFrameImpl::parent() const
 {
     return m_parent;
 }
 
-WebFrame* WebFrameImpl::top() const
+WebFrame* WebLocalFrameImpl::top() const
 {
-    WebFrameImpl* frame = const_cast<WebFrameImpl*>(this);
-    for (WebFrameImpl* parent = frame; parent; parent = parent->m_parent)
+    WebLocalFrameImpl* frame = const_cast<WebLocalFrameImpl*>(this);
+    for (WebLocalFrameImpl* parent = frame; parent; parent = parent->m_parent)
         frame = parent;
     return frame;
 }
 
-WebFrame* WebFrameImpl::previousSibling() const
+WebFrame* WebLocalFrameImpl::previousSibling() const
 {
     return m_previousSibling;
 }
 
-WebFrame* WebFrameImpl::nextSibling() const
+WebFrame* WebLocalFrameImpl::nextSibling() const
 {
     return m_nextSibling;
 }
 
-WebFrame* WebFrameImpl::firstChild() const
+WebFrame* WebLocalFrameImpl::firstChild() const
 {
     return m_firstChild;
 }
 
-WebFrame* WebFrameImpl::lastChild() const
+WebFrame* WebLocalFrameImpl::lastChild() const
 {
     return m_lastChild;
 }
 
-WebFrame* WebFrameImpl::traversePrevious(bool wrap) const
+WebFrame* WebLocalFrameImpl::traversePrevious(bool wrap) const
 {
     if (!frame())
         return 0;
     return fromFrame(frame()->tree().traversePreviousWithWrap(wrap));
 }
 
-WebFrame* WebFrameImpl::traverseNext(bool wrap) const
+WebFrame* WebLocalFrameImpl::traverseNext(bool wrap) const
 {
     if (!frame())
         return 0;
     return fromFrame(frame()->tree().traverseNextWithWrap(wrap));
 }
 
-WebFrame* WebFrameImpl::findChildByName(const WebString& name) const
+WebFrame* WebLocalFrameImpl::findChildByName(const WebString& name) const
 {
     if (!frame())
         return 0;
     return fromFrame(frame()->tree().child(name));
 }
 
-WebDocument WebFrameImpl::document() const
+WebDocument WebLocalFrameImpl::document() const
 {
     if (!frame() || !frame()->document())
         return WebDocument();
     return WebDocument(frame()->document());
 }
 
-WebPerformance WebFrameImpl::performance() const
+WebPerformance WebLocalFrameImpl::performance() const
 {
     if (!frame())
         return WebPerformance();
     return WebPerformance(&frame()->domWindow()->performance());
 }
 
-bool WebFrameImpl::dispatchBeforeUnloadEvent()
+bool WebLocalFrameImpl::dispatchBeforeUnloadEvent()
 {
     if (!frame())
         return true;
     return frame()->loader().shouldClose();
 }
 
-void WebFrameImpl::dispatchUnloadEvent()
+void WebLocalFrameImpl::dispatchUnloadEvent()
 {
     if (!frame())
         return;
     frame()->loader().closeURL();
 }
 
-NPObject* WebFrameImpl::windowObject() const
+NPObject* WebLocalFrameImpl::windowObject() const
 {
     if (!frame())
         return 0;
     return frame()->script().windowScriptNPObject();
 }
 
-void WebFrameImpl::bindToWindowObject(const WebString& name, NPObject* object)
+void WebLocalFrameImpl::bindToWindowObject(const WebString& name, NPObject* object)
 {
     bindToWindowObject(name, object, 0);
 }
 
-void WebFrameImpl::bindToWindowObject(const WebString& name, NPObject* object, void*)
+void WebLocalFrameImpl::bindToWindowObject(const WebString& name, NPObject* object, void*)
 {
     if (!frame() || !frame()->script().canExecuteScripts(NotAboutToExecuteScript))
         return;
     frame()->script().bindToWindowObject(frame(), String(name), object);
 }
 
-void WebFrameImpl::executeScript(const WebScriptSource& source)
+void WebLocalFrameImpl::executeScript(const WebScriptSource& source)
 {
     ASSERT(frame());
     TextPosition position(OrdinalNumber::fromOneBasedInt(source.startLine), OrdinalNumber::first());
     frame()->script().executeScriptInMainWorld(ScriptSourceCode(source.code, source.url, position));
 }
 
-void WebFrameImpl::executeScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup)
+void WebLocalFrameImpl::executeScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup)
 {
     ASSERT(frame());
     RELEASE_ASSERT(worldID > 0);
     RELEASE_ASSERT(worldID < EmbedderWorldIdLimit);
 
     Vector<ScriptSourceCode> sources;
     for (unsigned i = 0; i < numSources; ++i) {
         TextPosition position(OrdinalNumber::fromOneBasedInt(sourcesIn[i].startLine), OrdinalNumber::first());
         sources.append(ScriptSourceCode(sourcesIn[i].code, sourcesIn[i].url, position));
     }
 
     frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, 0);
 }
 
-void WebFrameImpl::setIsolatedWorldSecurityOrigin(int worldID, const WebSecurityOrigin& securityOrigin)
+void WebLocalFrameImpl::setIsolatedWorldSecurityOrigin(int worldID, const WebSecurityOrigin& securityOrigin)
 {
     ASSERT(frame());
     DOMWrapperWorld::setIsolatedWorldSecurityOrigin(worldID, securityOrigin.get());
 }
 
-void WebFrameImpl::setIsolatedWorldContentSecurityPolicy(int worldID, const WebString& policy)
+void WebLocalFrameImpl::setIsolatedWorldContentSecurityPolicy(int worldID, const WebString& policy)
 {
     ASSERT(frame());
     DOMWrapperWorld::setIsolatedWorldContentSecurityPolicy(worldID, policy);
 }
 
-void WebFrameImpl::addMessageToConsole(const WebConsoleMessage& message)
+void WebLocalFrameImpl::addMessageToConsole(const WebConsoleMessage& message)
 {
     ASSERT(frame());
 
     MessageLevel webCoreMessageLevel;
     switch (message.level) {
     case WebConsoleMessage::LevelDebug:
         webCoreMessageLevel = DebugMessageLevel;
         break;
     case WebConsoleMessage::LevelLog:
         webCoreMessageLevel = LogMessageLevel;
         break;
     case WebConsoleMessage::LevelWarning:
         webCoreMessageLevel = WarningMessageLevel;
         break;
     case WebConsoleMessage::LevelError:
         webCoreMessageLevel = ErrorMessageLevel;
         break;
     default:
         ASSERT_NOT_REACHED();
         return;
     }
 
     frame()->document()->addConsoleMessage(OtherMessageSource, webCoreMessageLevel, message.text);
 }
 
-void WebFrameImpl::collectGarbage()
+void WebLocalFrameImpl::collectGarbage()
 {
     if (!frame())
         return;
     if (!frame()->settings()->scriptEnabled())
         return;
     V8GCController::collectGarbage(v8::Isolate::GetCurrent());
 }
 
-bool WebFrameImpl::checkIfRunInsecureContent(const WebURL& url) const
+bool WebLocalFrameImpl::checkIfRunInsecureContent(const WebURL& url) const
 {
     ASSERT(frame());
     return frame()->loader().mixedContentChecker()->canRunInsecureContent(frame()->document()->securityOrigin(), url);
 }
 
-v8::Handle<v8::Value> WebFrameImpl::executeScriptAndReturnValue(const WebScriptSource& source)
+v8::Handle<v8::Value> WebLocalFrameImpl::executeScriptAndReturnValue(const WebScriptSource& source)
 {
     ASSERT(frame());
 
     // FIXME: This fake user gesture is required to make a bunch of pyauto
     // tests pass. If this isn't needed in non-test situations, we should
     // consider removing this code and changing the tests.
     // http://code.google.com/p/chromium/issues/detail?id=86397
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
 
     TextPosition position(OrdinalNumber::fromOneBasedInt(source.startLine), OrdinalNumber::first());
     return frame()->script().executeScriptInMainWorldAndReturnValue(ScriptSourceCode(source.code, source.url, position)).v8Value();
 }
 
-void WebFrameImpl::executeScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup, WebVector<v8::Local<v8::Value> >* results)
+void WebLocalFrameImpl::executeScriptInIsolatedWorld(int worldID, const WebScriptSource* sourcesIn, unsigned numSources, int extensionGroup, WebVector<v8::Local<v8::Value> >* results)
 {
     ASSERT(frame());
     RELEASE_ASSERT(worldID > 0);
     RELEASE_ASSERT(worldID < EmbedderWorldIdLimit);
 
     Vector<ScriptSourceCode> sources;
 
     for (unsigned i = 0; i < numSources; ++i) {
         TextPosition position(OrdinalNumber::fromOneBasedInt(sourcesIn[i].startLine), OrdinalNumber::first());
         sources.append(ScriptSourceCode(sourcesIn[i].code, sourcesIn[i].url, position));
     }
 
     if (results) {
         Vector<ScriptValue> scriptResults;
         frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, &scriptResults);
         WebVector<v8::Local<v8::Value> > v8Results(scriptResults.size());
         for (unsigned i = 0; i < scriptResults.size(); i++)
             v8Results[i] = v8::Local<v8::Value>::New(toIsolate(frame()), scriptResults[i].v8Value());
         results->swap(v8Results);
     } else {
         frame()->script().executeScriptInIsolatedWorld(worldID, sources, extensionGroup, 0);
     }
 }
 
-v8::Handle<v8::Value> WebFrameImpl::callFunctionEvenIfScriptDisabled(v8::Handle<v8::Function> function, v8::Handle<v8::Value> receiver, int argc, v8::Handle<v8::Value> argv[])
+v8::Handle<v8::Value> WebLocalFrameImpl::callFunctionEvenIfScriptDisabled(v8::Handle<v8::Function> function, v8::Handle<v8::Value> receiver, int argc, v8::Handle<v8::Value> argv[])
 {
     ASSERT(frame());
     return frame()->script().callFunction(function, receiver, argc, argv);
 }
 
-v8::Local<v8::Context> WebFrameImpl::mainWorldScriptContext() const
+v8::Local<v8::Context> WebLocalFrameImpl::mainWorldScriptContext() const
 {
     return toV8Context(V8PerIsolateData::mainThreadIsolate(), frame(), DOMWrapperWorld::mainWorld());
 }
 
-void WebFrameImpl::reload(bool ignoreCache)
+void WebLocalFrameImpl::reload(bool ignoreCache)
 {
     ASSERT(frame());
     frame()->loader().reload(ignoreCache ? EndToEndReload : NormalReload);
 }
 
-void WebFrameImpl::reloadWithOverrideURL(const WebURL& overrideUrl, bool ignoreCache)
+void WebLocalFrameImpl::reloadWithOverrideURL(const WebURL& overrideUrl, bool ignoreCache)
 {
     ASSERT(frame());
     frame()->loader().reload(ignoreCache ? EndToEndReload : NormalReload, overrideUrl);
 }
 
-void WebFrameImpl::loadRequest(const WebURLRequest& request)
+void WebLocalFrameImpl::loadRequest(const WebURLRequest& request)
 {
     ASSERT(frame());
     ASSERT(!request.isNull());
     const ResourceRequest& resourceRequest = request.toResourceRequest();
 
     if (resourceRequest.url().protocolIs("javascript")) {
         loadJavaScriptURL(resourceRequest.url());
         return;
     }
 
     frame()->loader().load(FrameLoadRequest(0, resourceRequest));
 }
 
-void WebFrameImpl::loadHistoryItem(const WebHistoryItem& item, WebHistoryLoadType loadType, WebURLRequest::CachePolicy cachePolicy)
+void WebLocalFrameImpl::loadHistoryItem(const WebHistoryItem& item, WebHistoryLoadType loadType, WebURLRequest::CachePolicy cachePolicy)
 {
     ASSERT(frame());
     RefPtr<HistoryItem> historyItem = PassRefPtr<HistoryItem>(item);
     ASSERT(historyItem);
     frame()->loader().loadHistoryItem(historyItem.get(), static_cast<HistoryLoadType>(loadType), static_cast<ResourceRequestCachePolicy>(cachePolicy));
 }
 
-void WebFrameImpl::loadData(const WebData& data, const WebString& mimeType, const WebString& textEncoding, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
+void WebLocalFrameImpl::loadData(const WebData& data, const WebString& mimeType, const WebString& textEncoding, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
 {
     ASSERT(frame());
 
     // If we are loading substitute data to replace an existing load, then
-    // inherit all of the properties of that original request.  This way,
-    // reload will re-attempt the original request.  It is essential that
+    // inherit all of the properties of that original request. This way,
+    // reload will re-attempt the original request. It is essential that
     // we only do this when there is an unreachableURL since a non-empty
     // unreachableURL informs FrameLoader::reload to load unreachableURL
     // instead of the currently loaded URL.
     ResourceRequest request;
     if (replace && !unreachableURL.isEmpty() && frame()->loader().provisionalDocumentLoader())
         request = frame()->loader().provisionalDocumentLoader()->originalRequest();
     request.setURL(baseURL);
 
     FrameLoadRequest frameRequest(0, request, SubstituteData(data, mimeType, textEncoding, unreachableURL));
     ASSERT(frameRequest.substituteData().isValid());
     frameRequest.setLockBackForwardList(replace);
     frame()->loader().load(frameRequest);
 }
 
-void WebFrameImpl::loadHTMLString(const WebData& data, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
+void WebLocalFrameImpl::loadHTMLString(const WebData& data, const WebURL& baseURL, const WebURL& unreachableURL, bool replace)
 {
     ASSERT(frame());
     loadData(data, WebString::fromUTF8("text/html"), WebString::fromUTF8("UTF-8"), baseURL, unreachableURL, replace);
 }
 
-bool WebFrameImpl::isLoading() const
+bool WebLocalFrameImpl::isLoading() const
 {
     if (!frame())
         return false;
     return frame()->loader().isLoading();
 }
 
-void WebFrameImpl::stopLoading()
+void WebLocalFrameImpl::stopLoading()
 {
     if (!frame())
         return;
-    // FIXME: Figure out what we should really do here.  It seems like a bug
+    // FIXME: Figure out what we should really do here. It seems like a bug
     // that FrameLoader::stopLoading doesn't call stopAllLoaders.
     frame()->loader().stopAllLoaders();
 }
 
-WebDataSource* WebFrameImpl::provisionalDataSource() const
+WebDataSource* WebLocalFrameImpl::provisionalDataSource() const
 {
     ASSERT(frame());
 
     // We regard the policy document loader as still provisional.
     DocumentLoader* documentLoader = frame()->loader().provisionalDocumentLoader();
     if (!documentLoader)
         documentLoader = frame()->loader().policyDocumentLoader();
 
     return DataSourceForDocLoader(documentLoader);
 }
 
-WebDataSource* WebFrameImpl::dataSource() const
+WebDataSource* WebLocalFrameImpl::dataSource() const
 {
     ASSERT(frame());
     return DataSourceForDocLoader(frame()->loader().documentLoader());
 }
 
-void WebFrameImpl::enableViewSourceMode(bool enable)
+void WebLocalFrameImpl::enableViewSourceMode(bool enable)
 {
     if (frame())
         frame()->setInViewSourceMode(enable);
 }
 
-bool WebFrameImpl::isViewSourceModeEnabled() const
+bool WebLocalFrameImpl::isViewSourceModeEnabled() const
 {
     if (!frame())
         return false;
     return frame()->inViewSourceMode();
 }
 
-void WebFrameImpl::setReferrerForRequest(WebURLRequest& request, const WebURL& referrerURL)
+void WebLocalFrameImpl::setReferrerForRequest(WebURLRequest& request, const WebURL& referrerURL)
 {
     String referrer = referrerURL.isEmpty() ? frame()->document()->outgoingReferrer() : String(referrerURL.spec().utf16());
     referrer = SecurityPolicy::generateReferrerHeader(frame()->document()->referrerPolicy(), request.url(), referrer);
     if (referrer.isEmpty())
         return;
     request.setHTTPReferrer(referrer, static_cast<WebReferrerPolicy>(frame()->document()->referrerPolicy()));
 }
 
-void WebFrameImpl::dispatchWillSendRequest(WebURLRequest& request)
+void WebLocalFrameImpl::dispatchWillSendRequest(WebURLRequest& request)
 {
     ResourceResponse response;
     frame()->loader().client()->dispatchWillSendRequest(0, 0, request.toMutableResourceRequest(), response);
 }
 
-WebURLLoader* WebFrameImpl::createAssociatedURLLoader(const WebURLLoaderOptions& options)
+WebURLLoader* WebLocalFrameImpl::createAssociatedURLLoader(const WebURLLoaderOptions& options)
 {
     return new AssociatedURLLoader(this, options);
 }
 
-unsigned WebFrameImpl::unloadListenerCount() const
+unsigned WebLocalFrameImpl::unloadListenerCount() const
 {
     return frame()->domWindow()->pendingUnloadEventListeners();
 }
 
-void WebFrameImpl::replaceSelection(const WebString& text)
+void WebLocalFrameImpl::replaceSelection(const WebString& text)
 {
     bool selectReplacement = false;
     bool smartReplace = true;
     frame()->editor().replaceSelectionWithText(text, selectReplacement, smartReplace);
 }
 
-void WebFrameImpl::insertText(const WebString& text)
+void WebLocalFrameImpl::insertText(const WebString& text)
 {
     if (frame()->inputMethodController().hasComposition())
         frame()->inputMethodController().confirmComposition(text);
     else
         frame()->editor().insertText(text, 0);
 }
 
-void WebFrameImpl::setMarkedText(const WebString& text, unsigned location, unsigned length)
+void WebLocalFrameImpl::setMarkedText(const WebString& text, unsigned location, unsigned length)
 {
     Vector<CompositionUnderline> decorations;
     frame()->inputMethodController().setComposition(text, decorations, location, length);
 }
 
-void WebFrameImpl::unmarkText()
+void WebLocalFrameImpl::unmarkText()
 {
     frame()->inputMethodController().cancelComposition();
 }
 
-bool WebFrameImpl::hasMarkedText() const
+bool WebLocalFrameImpl::hasMarkedText() const
 {
     return frame()->inputMethodController().hasComposition();
 }
 
-WebRange WebFrameImpl::markedRange() const
+WebRange WebLocalFrameImpl::markedRange() const
 {
     return frame()->inputMethodController().compositionRange();
 }
 
-bool WebFrameImpl::firstRectForCharacterRange(unsigned location, unsigned length, WebRect& rect) const
+bool WebLocalFrameImpl::firstRectForCharacterRange(unsigned location, unsigned length, WebRect& rect) const
 {
     if ((location + length < location) && (location + length))
         length = 0;
 
     Element* editable = frame()->selection().rootEditableElementOrDocumentElement();
     ASSERT(editable);
     RefPtrWillBeRawPtr<Range> range = PlainTextRange(location, location + length).createRange(*editable);
     if (!range)
         return false;
     IntRect intRect = frame()->editor().firstRectForRange(range.get());
     rect = WebRect(intRect);
     rect = frame()->view()->contentsToWindow(rect);
     return true;
 }
 
-size_t WebFrameImpl::characterIndexForPoint(const WebPoint& webPoint) const
+size_t WebLocalFrameImpl::characterIndexForPoint(const WebPoint& webPoint) const
 {
     if (!frame())
         return kNotFound;
 
     IntPoint point = frame()->view()->windowToContents(webPoint);
     HitTestResult result = frame()->eventHandler().hitTestResultAtPoint(point, HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent);
     RefPtrWillBeRawPtr<Range> range = frame()->rangeForPoint(result.roundedPointInInnerNodeFrame());
     if (!range)
         return kNotFound;
     Element* editable = frame()->selection().rootEditableElementOrDocumentElement();
     ASSERT(editable);
     return PlainTextRange::create(*editable, *range.get()).start();
 }
 
-bool WebFrameImpl::executeCommand(const WebString& name, const WebNode& node)
+bool WebLocalFrameImpl::executeCommand(const WebString& name, const WebNode& node)
 {
     ASSERT(frame());
 
     if (name.length() <= 2)
         return false;
 
     // Since we don't have NSControl, we will convert the format of command
     // string and call the function on Editor directly.
     String command = name;
 
@@ skipping 27 matching lines @@
         // Wee need to pass false here or else the currently selected word will never be skipped.
         frame()->spellChecker().advanceToNextMisspelling(false);
     } else if (command == "ToggleSpellPanel") {
         frame()->spellChecker().showSpellingGuessPanel();
     } else {
         result = frame()->editor().command(command).execute();
     }
     return result;
 }
 
-bool WebFrameImpl::executeCommand(const WebString& name, const WebString& value, const WebNode& node)
+bool WebLocalFrameImpl::executeCommand(const WebString& name, const WebString& value, const WebNode& node)
 {
     ASSERT(frame());
     String webName = name;
 
     WebPluginContainerImpl* pluginContainer = pluginContainerFromNode(frame(), node);
     if (pluginContainer && pluginContainer->executeEditCommand(name, value))
         return true;
 
     // moveToBeginningOfDocument and moveToEndfDocument are only handled by WebKit for editable nodes.
     if (!frame()->editor().canEdit() && webName == "moveToBeginningOfDocument")
         return viewImpl()->bubblingScroll(ScrollUp, ScrollByDocument);
 
     if (!frame()->editor().canEdit() && webName == "moveToEndOfDocument")
         return viewImpl()->bubblingScroll(ScrollDown, ScrollByDocument);
 
     if (webName == "showGuessPanel") {
         frame()->spellChecker().showSpellingGuessPanel();
         return true;
     }
 
     return frame()->editor().command(webName).execute(value);
 }
 
-bool WebFrameImpl::isCommandEnabled(const WebString& name) const
+bool WebLocalFrameImpl::isCommandEnabled(const WebString& name) const
 {
     ASSERT(frame());
     return frame()->editor().command(name).isEnabled();
 }
 
-void WebFrameImpl::enableContinuousSpellChecking(bool enable)
+void WebLocalFrameImpl::enableContinuousSpellChecking(bool enable)
 {
     if (enable == isContinuousSpellCheckingEnabled())
         return;
     frame()->spellChecker().toggleContinuousSpellChecking();
 }
 
-bool WebFrameImpl::isContinuousSpellCheckingEnabled() const
+bool WebLocalFrameImpl::isContinuousSpellCheckingEnabled() const
 {
     return frame()->spellChecker().isContinuousSpellCheckingEnabled();
 }
 
-void WebFrameImpl::requestTextChecking(const WebElement& webElement)
+void WebLocalFrameImpl::requestTextChecking(const WebElement& webElement)
 {
     if (webElement.isNull())
         return;
     frame()->spellChecker().requestTextChecking(*webElement.constUnwrap<Element>());
 }
 
-void WebFrameImpl::replaceMisspelledRange(const WebString& text)
+void WebLocalFrameImpl::replaceMisspelledRange(const WebString& text)
 {
     // If this caret selection has two or more markers, this function replace the range covered by the first marker with the specified word as Microsoft Word does.
     if (pluginContainerFromFrame(frame()))
         return;
     RefPtrWillBeRawPtr<Range> caretRange = frame()->selection().toNormalizedRange();
     if (!caretRange)
         return;
     Vector<DocumentMarker*> markers = frame()->document()->markers().markersInRange(caretRange.get(), DocumentMarker::MisspellingMarkers());
     if (markers.size() < 1 || markers[0]->startOffset() >= markers[0]->endOffset())
         return;
     RefPtrWillBeRawPtr<Range> markerRange = Range::create(caretRange->ownerDocument(), caretRange->startContainer(), markers[0]->startOffset(), caretRange->endContainer(), markers[0]->endOffset());
     if (!markerRange)
         return;
     frame()->selection().setSelection(VisibleSelection(markerRange.get()), CharacterGranularity);
     frame()->editor().replaceSelectionWithText(text, false, false);
 }
 
-void WebFrameImpl::removeSpellingMarkers()
+void WebLocalFrameImpl::removeSpellingMarkers()
 {
     frame()->document()->markers().removeMarkers(DocumentMarker::MisspellingMarkers());
 }
 
-bool WebFrameImpl::hasSelection() const
+bool WebLocalFrameImpl::hasSelection() const
 {
     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
     if (pluginContainer)
         return pluginContainer->plugin()->hasSelection();
 
     // frame()->selection()->isNone() never returns true.
     return frame()->selection().start() != frame()->selection().end();
 }
 
-WebRange WebFrameImpl::selectionRange() const
+WebRange WebLocalFrameImpl::selectionRange() const
 {
     return frame()->selection().toNormalizedRange();
 }
 
-WebString WebFrameImpl::selectionAsText() const
+WebString WebLocalFrameImpl::selectionAsText() const
 {
     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
     if (pluginContainer)
         return pluginContainer->plugin()->selectionAsText();
 
     RefPtrWillBeRawPtr<Range> range = frame()->selection().toNormalizedRange();
     if (!range)
         return WebString();
 
     String text = range->text();
 #if OS(WIN)
     replaceNewlinesWithWindowsStyleNewlines(text);
 #endif
     replaceNBSPWithSpace(text);
     return text;
 }
 
-WebString WebFrameImpl::selectionAsMarkup() const
+WebString WebLocalFrameImpl::selectionAsMarkup() const
 {
     WebPluginContainerImpl* pluginContainer = pluginContainerFromFrame(frame());
     if (pluginContainer)
         return pluginContainer->plugin()->selectionAsMarkup();
 
     RefPtrWillBeRawPtr<Range> range = frame()->selection().toNormalizedRange();
     if (!range)
         return WebString();
 
     return createMarkup(range.get(), 0, AnnotateForInterchange, false, ResolveNonLocalURLs);
 }
 
-void WebFrameImpl::selectWordAroundPosition(LocalFrame* frame, VisiblePosition position)
+void WebLocalFrameImpl::selectWordAroundPosition(LocalFrame* frame, VisiblePosition position)
 {
     VisibleSelection selection(position);
     selection.expandUsingGranularity(WordGranularity);
 
     TextGranularity granularity = selection.isRange() ? WordGranularity : CharacterGranularity;
     frame->selection().setSelection(selection, granularity);
 }
 
-bool WebFrameImpl::selectWordAroundCaret()
+bool WebLocalFrameImpl::selectWordAroundCaret()
 {
     FrameSelection& selection = frame()->selection();
     ASSERT(!selection.isNone());
     if (selection.isNone() || selection.isRange())
         return false;
     selectWordAroundPosition(frame(), selection.selection().visibleStart());
     return true;
 }
 
-void WebFrameImpl::selectRange(const WebPoint& base, const WebPoint& extent)
+void WebLocalFrameImpl::selectRange(const WebPoint& base, const WebPoint& extent)
 {
     moveRangeSelection(base, extent);
 }
 
-void WebFrameImpl::selectRange(const WebRange& webRange)
+void WebLocalFrameImpl::selectRange(const WebRange& webRange)
 {
     if (RefPtrWillBeRawPtr<Range> range = static_cast<PassRefPtrWillBeRawPtr<Range> >(webRange))
         frame()->selection().setSelectedRange(range.get(), WebCore::VP_DEFAULT_AFFINITY, false);
 }
 
-void WebFrameImpl::moveRangeSelection(const WebPoint& base, const WebPoint& extent)
+void WebLocalFrameImpl::moveRangeSelection(const WebPoint& base, const WebPoint& extent)
 {
     VisiblePosition basePosition = visiblePositionForWindowPoint(base);
     VisiblePosition extentPosition = visiblePositionForWindowPoint(extent);
     VisibleSelection newSelection = VisibleSelection(basePosition, extentPosition);
     frame()->selection().setSelection(newSelection, CharacterGranularity);
 }
 
-void WebFrameImpl::moveCaretSelection(const WebPoint& point)
+void WebLocalFrameImpl::moveCaretSelection(const WebPoint& point)
 {
     Element* editable = frame()->selection().rootEditableElement();
     if (!editable)
         return;
 
     VisiblePosition position = visiblePositionForWindowPoint(point);
     frame()->selection().moveTo(position, UserTriggered);
 }
 
-bool WebFrameImpl::setEditableSelectionOffsets(int start, int end)
+bool WebLocalFrameImpl::setEditableSelectionOffsets(int start, int end)
 {
     return frame()->inputMethodController().setEditableSelectionOffsets(PlainTextRange(start, end));
 }
 
-bool WebFrameImpl::setCompositionFromExistingText(int compositionStart, int compositionEnd, const WebVector<WebCompositionUnderline>& underlines)
+bool WebLocalFrameImpl::setCompositionFromExistingText(int compositionStart, int compositionEnd, const WebVector<WebCompositionUnderline>& underlines)
 {
     if (!frame()->editor().canEdit())
         return false;
 
     InputMethodController& inputMethodController = frame()->inputMethodController();
     inputMethodController.cancelComposition();
 
     if (compositionStart == compositionEnd)
         return true;
 
     inputMethodController.setCompositionFromExistingText(CompositionUnderlineVectorBuilder(underlines), compositionStart, compositionEnd);
 
     return true;
 }
 
-void WebFrameImpl::extendSelectionAndDelete(int before, int after)
+void WebLocalFrameImpl::extendSelectionAndDelete(int before, int after)
 {
     if (WebPlugin* plugin = focusedPluginIfInputMethodSupported()) {
         plugin->extendSelectionAndDelete(before, after);
         return;
     }
     frame()->inputMethodController().extendSelectionAndDelete(before, after);
 }
 
-void WebFrameImpl::setCaretVisible(bool visible)
+void WebLocalFrameImpl::setCaretVisible(bool visible)
 {
     frame()->selection().setCaretVisible(visible);
 }
 
-VisiblePosition WebFrameImpl::visiblePositionForWindowPoint(const WebPoint& point)
+VisiblePosition WebLocalFrameImpl::visiblePositionForWindowPoint(const WebPoint& point)
 {
     FloatPoint unscaledPoint(point);
     unscaledPoint.scale(1 / view()->pageScaleFactor(), 1 / view()->pageScaleFactor());
 
     HitTestRequest request = HitTestRequest::Move | HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::IgnoreClipping | HitTestRequest::ConfusingAndOftenMisusedDisallowShadowContent;
     HitTestResult result(frame()->view()->windowToContents(roundedIntPoint(unscaledPoint)));
     frame()->document()->renderView()->layer()->hitTest(request, result);
 
     if (Node* node = result.targetNode())
         return frame()->selection().selection().visiblePositionRespectingEditingBoundary(result.localPoint(), node);
     return VisiblePosition();
 }
 
-WebPlugin* WebFrameImpl::focusedPluginIfInputMethodSupported()
+WebPlugin* WebLocalFrameImpl::focusedPluginIfInputMethodSupported()
 {
-    WebPluginContainerImpl* container = WebFrameImpl::pluginContainerFromNode(frame(), WebNode(frame()->document()->focusedElement()));
+    WebPluginContainerImpl* container = WebLocalFrameImpl::pluginContainerFromNode(frame(), WebNode(frame()->document()->focusedElement()));
     if (container && container->supportsInputMethod())
         return container->plugin();
     return 0;
 }
 
-NotificationPresenterImpl* WebFrameImpl::notificationPresenterImpl()
+NotificationPresenterImpl* WebLocalFrameImpl::notificationPresenterImpl()
 {
     if (!m_notificationPresenter.isInitialized() && m_client)
         m_notificationPresenter.initialize(m_client->notificationPresenter());
     return &m_notificationPresenter;
 }
 
-int WebFrameImpl::printBegin(const WebPrintParams& printParams, const WebNode& constrainToNode)
+int WebLocalFrameImpl::printBegin(const WebPrintParams& printParams, const WebNode& constrainToNode)
 {
     ASSERT(!frame()->document()->isFrameSet());
     WebPluginContainerImpl* pluginContainer = 0;
     if (constrainToNode.isNull()) {
         // If this is a plugin document, check if the plugin supports its own
         // printing. If it does, we will delegate all printing to that.
         pluginContainer = pluginContainerFromFrame(frame());
     } else {
         // We only support printing plugin nodes for now.
         pluginContainer = toWebPluginContainerImpl(constrainToNode.pluginContainer());
     }
 
     if (pluginContainer && pluginContainer->supportsPaginatedPrint())
         m_printContext = adoptPtr(new ChromePluginPrintContext(frame(), pluginContainer, printParams));
     else
         m_printContext = adoptPtr(new ChromePrintContext(frame()));
 
     FloatRect rect(0, 0, static_cast<float>(printParams.printContentArea.width), static_cast<float>(printParams.printContentArea.height));
     m_printContext->begin(rect.width(), rect.height());
     float pageHeight;
     // We ignore the overlays calculation for now since they are generated in the
     // browser. pageHeight is actually an output parameter.
     m_printContext->computePageRects(rect, 0, 0, 1.0, pageHeight);
 
     return m_printContext->pageCount();
 }
 
-float WebFrameImpl::getPrintPageShrink(int page)
+float WebLocalFrameImpl::getPrintPageShrink(int page)
 {
     ASSERT(m_printContext && page >= 0);
     return m_printContext->getPageShrink(page);
 }
 
-float WebFrameImpl::printPage(int page, WebCanvas* canvas)
+float WebLocalFrameImpl::printPage(int page, WebCanvas* canvas)
 {
 #if ENABLE(PRINTING)
     ASSERT(m_printContext && page >= 0 && frame() && frame()->document());
 
     GraphicsContext graphicsContext(canvas);
     graphicsContext.setPrinting(true);
     return m_printContext->spoolPage(graphicsContext, page);
 #else
     return 0;
 #endif
 }
 
-void WebFrameImpl::printEnd()
+void WebLocalFrameImpl::printEnd()
 {
     ASSERT(m_printContext);
     m_printContext->end();
     m_printContext.clear();
 }
 
-bool WebFrameImpl::isPrintScalingDisabledForPlugin(const WebNode& node)
+bool WebLocalFrameImpl::isPrintScalingDisabledForPlugin(const WebNode& node)
 {
     WebPluginContainerImpl* pluginContainer =  node.isNull() ? pluginContainerFromFrame(frame()) : toWebPluginContainerImpl(node.pluginContainer());
 
     if (!pluginContainer || !pluginContainer->supportsPaginatedPrint())
         return false;
 
     return pluginContainer->isPrintScalingDisabled();
 }
 
-bool WebFrameImpl::hasCustomPageSizeStyle(int pageIndex)
+bool WebLocalFrameImpl::hasCustomPageSizeStyle(int pageIndex)
 {
     return frame()->document()->styleForPage(pageIndex)->pageSizeType() != PAGE_SIZE_AUTO;
 }
 
-bool WebFrameImpl::isPageBoxVisible(int pageIndex)
+bool WebLocalFrameImpl::isPageBoxVisible(int pageIndex)
 {
     return frame()->document()->isPageBoxVisible(pageIndex);
 }
 
-void WebFrameImpl::pageSizeAndMarginsInPixels(int pageIndex, WebSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
+void WebLocalFrameImpl::pageSizeAndMarginsInPixels(int pageIndex, WebSize& pageSize, int& marginTop, int& marginRight, int& marginBottom, int& marginLeft)
 {
     IntSize size = pageSize;
     frame()->document()->pageSizeAndMarginsInPixels(pageIndex, size, marginTop, marginRight, marginBottom, marginLeft);
     pageSize = size;
 }
 
-WebString WebFrameImpl::pageProperty(const WebString& propertyName, int pageIndex)
+WebString WebLocalFrameImpl::pageProperty(const WebString& propertyName, int pageIndex)
 {
     ASSERT(m_printContext);
     return m_printContext->pageProperty(frame(), propertyName.utf8().data(), pageIndex);
 }
 
-bool WebFrameImpl::find(int identifier, const WebString& searchText, const WebFindOptions& options, bool wrapWithinFrame, WebRect* selectionRect)
+bool WebLocalFrameImpl::find(int identifier, const WebString& searchText, const WebFindOptions& options, bool wrapWithinFrame, WebRect* selectionRect)
 {
     return ensureTextFinder().find(identifier, searchText, options, wrapWithinFrame, selectionRect);
 }
 
-void WebFrameImpl::stopFinding(bool clearSelection)
+void WebLocalFrameImpl::stopFinding(bool clearSelection)
 {
     if (m_textFinder) {
         if (!clearSelection)
             setFindEndstateFocusAndSelection();
         m_textFinder->stopFindingAndClearSelection();
     }
 }
 
-void WebFrameImpl::scopeStringMatches(int identifier, const WebString& searchText, const WebFindOptions& options, bool reset)
+void WebLocalFrameImpl::scopeStringMatches(int identifier, const WebString& searchText, const WebFindOptions& options, bool reset)
 {
     ensureTextFinder().scopeStringMatches(identifier, searchText, options, reset);
 }
 
-void WebFrameImpl::cancelPendingScopingEffort()
+void WebLocalFrameImpl::cancelPendingScopingEffort()
 {
     if (m_textFinder)
         m_textFinder->cancelPendingScopingEffort();
 }
 
-void WebFrameImpl::increaseMatchCount(int count, int identifier)
+void WebLocalFrameImpl::increaseMatchCount(int count, int identifier)
 {
     // This function should only be called on the mainframe.
     ASSERT(!parent());
     ASSERT(m_textFinder);
     m_textFinder->increaseMatchCount(identifier, count);
 }
 
-void WebFrameImpl::resetMatchCount()
+void WebLocalFrameImpl::resetMatchCount()
 {
     ASSERT(m_textFinder);
     m_textFinder->resetMatchCount();
 }
 
-void WebFrameImpl::sendOrientationChangeEvent(int orientation)
+void WebLocalFrameImpl::sendOrientationChangeEvent(int orientation)
 {
     if (frame())
         frame()->sendOrientationChangeEvent(orientation);
 }
 
-void WebFrameImpl::dispatchMessageEventWithOriginCheck(const WebSecurityOrigin& intendedTargetOrigin, const WebDOMEvent& event)
+void WebLocalFrameImpl::dispatchMessageEventWithOriginCheck(const WebSecurityOrigin& intendedTargetOrigin, const WebDOMEvent& event)
 {
     ASSERT(!event.isNull());
     frame()->domWindow()->dispatchMessageEventWithOriginCheck(intendedTargetOrigin.get(), event, nullptr);
 }
 
-int WebFrameImpl::findMatchMarkersVersion() const
+int WebLocalFrameImpl::findMatchMarkersVersion() const
 {
     ASSERT(!parent());
 
     if (m_textFinder)
         return m_textFinder->findMatchMarkersVersion();
     return 0;
 }
 
-int WebFrameImpl::selectNearestFindMatch(const WebFloatPoint& point, WebRect* selectionRect)
+int WebLocalFrameImpl::selectNearestFindMatch(const WebFloatPoint& point, WebRect* selectionRect)
 {
     ASSERT(!parent());
     ASSERT(m_textFinder);
     return m_textFinder->selectNearestFindMatch(point, selectionRect);
 }
 
-WebFloatRect WebFrameImpl::activeFindMatchRect()
+WebFloatRect WebLocalFrameImpl::activeFindMatchRect()
 {
     ASSERT(!parent());
 
     if (m_textFinder)
         return m_textFinder->activeFindMatchRect();
     return WebFloatRect();
 }
 
-void WebFrameImpl::findMatchRects(WebVector<WebFloatRect>& outputRects)
+void WebLocalFrameImpl::findMatchRects(WebVector<WebFloatRect>& outputRects)
 {
     ASSERT(!parent());
     ASSERT(m_textFinder);
     m_textFinder->findMatchRects(outputRects);
 }
 
-void WebFrameImpl::setTickmarks(const WebVector<WebRect>& tickmarks)
+void WebLocalFrameImpl::setTickmarks(const WebVector<WebRect>& tickmarks)
 {
     if (frameView()) {
         Vector<IntRect> tickmarksConverted(tickmarks.size());
         for (size_t i = 0; i < tickmarks.size(); ++i)
             tickmarksConverted[i] = tickmarks[i];
         frameView()->setTickmarks(tickmarksConverted);
         invalidateScrollbar();
     }
 }
 
-WebString WebFrameImpl::contentAsText(size_t maxChars) const
+WebString WebLocalFrameImpl::contentAsText(size_t maxChars) const
 {
     if (!frame())
         return WebString();
     StringBuilder text;
     frameContentAsPlainText(maxChars, frame(), text);
     return text.toString();
 }
 
-WebString WebFrameImpl::contentAsMarkup() const
+WebString WebLocalFrameImpl::contentAsMarkup() const
 {
     if (!frame())
         return WebString();
     return createFullMarkup(frame()->document());
 }
 
-WebString WebFrameImpl::renderTreeAsText(RenderAsTextControls toShow) const
+WebString WebLocalFrameImpl::renderTreeAsText(RenderAsTextControls toShow) const
 {
     RenderAsTextBehavior behavior = RenderAsTextBehaviorNormal;
 
     if (toShow & RenderAsTextDebug)
         behavior |= RenderAsTextShowCompositedLayers | RenderAsTextShowAddresses | RenderAsTextShowIDAndClass | RenderAsTextShowLayerNesting;
 
     if (toShow & RenderAsTextPrinting)
         behavior |= RenderAsTextPrintingMode;
 
     return externalRepresentation(frame(), behavior);
 }
 
-WebString WebFrameImpl::markerTextForListItem(const WebElement& webElement) const
+WebString WebLocalFrameImpl::markerTextForListItem(const WebElement& webElement) const
 {
     return WebCore::markerTextForListItem(const_cast<Element*>(webElement.constUnwrap<Element>()));
 }
 
-void WebFrameImpl::printPagesWithBoundaries(WebCanvas* canvas, const WebSize& pageSizeInPixels)
+void WebLocalFrameImpl::printPagesWithBoundaries(WebCanvas* canvas, const WebSize& pageSizeInPixels)
 {
     ASSERT(m_printContext);
 
     GraphicsContext graphicsContext(canvas);
     graphicsContext.setPrinting(true);
 
     m_printContext->spoolAllPagesWithBoundaries(graphicsContext, FloatSize(pageSizeInPixels.width, pageSizeInPixels.height));
 }
 
-WebRect WebFrameImpl::selectionBoundsRect() const
+WebRect WebLocalFrameImpl::selectionBoundsRect() const
 {
     return hasSelection() ? WebRect(IntRect(frame()->selection().bounds(false))) : WebRect();
 }
 
-bool WebFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) const
+bool WebLocalFrameImpl::selectionStartHasSpellingMarkerFor(int from, int length) const
 {
     if (!frame())
         return false;
     return frame()->spellChecker().selectionStartHasMarkerFor(DocumentMarker::Spelling, from, length);
 }
 
-WebString WebFrameImpl::layerTreeAsText(bool showDebugInfo) const
+WebString WebLocalFrameImpl::layerTreeAsText(bool showDebugInfo) const
 {
     if (!frame())
         return WebString();
 
     return WebString(frame()->layerTreeAsText(showDebugInfo ? LayerTreeIncludesDebugInfo : LayerTreeNormal));
 }
 
-// WebFrameImpl public ---------------------------------------------------------
+// WebLocalFrameImpl public ---------------------------------------------------------
 
 WebLocalFrame* WebLocalFrame::create(WebFrameClient* client)
 {
-    return WebFrameImpl::create(client);
+    return WebLocalFrameImpl::create(client);
 }
 
-WebFrameImpl* WebFrameImpl::create(WebFrameClient* client)
+WebLocalFrameImpl* WebLocalFrameImpl::create(WebFrameClient* client)
 {
-    return adoptRef(new WebFrameImpl(client)).leakRef();
+    return adoptRef(new WebLocalFrameImpl(client)).leakRef();
 }
 
-WebFrameImpl::WebFrameImpl(WebFrameClient* client)
+WebLocalFrameImpl::WebLocalFrameImpl(WebFrameClient* client)
     : m_frameLoaderClientImpl(this)
     , m_parent(0)
     , m_previousSibling(0)
     , m_nextSibling(0)
     , m_firstChild(0)
     , m_lastChild(0)
     , m_opener(0)
     , m_client(client)
     , m_permissionClient(0)
     , m_inputEventsScaleFactorForEmulation(1)
 {
     blink::Platform::current()->incrementStatsCounter(webFrameActiveCount);
     frameCount++;
 }
 
-WebFrameImpl::~WebFrameImpl()
+WebLocalFrameImpl::~WebLocalFrameImpl()
 {
-    HashSet<WebFrameImpl*>::iterator end = m_openedFrames.end();
-    for (HashSet<WebFrameImpl*>::iterator it = m_openedFrames.begin(); it != end; ++it)
+    HashSet<WebLocalFrameImpl*>::iterator end = m_openedFrames.end();
+    for (HashSet<WebLocalFrameImpl*>::iterator it = m_openedFrames.begin(); it != end; ++it)
         (*it)->m_opener = 0;
 
     blink::Platform::current()->decrementStatsCounter(webFrameActiveCount);
     frameCount--;
 
     cancelPendingScopingEffort();
 }
 
-void WebFrameImpl::setWebCoreFrame(PassRefPtr<WebCore::LocalFrame> frame)
+void WebLocalFrameImpl::setWebCoreFrame(PassRefPtr<WebCore::LocalFrame> frame)
 {
     m_frame = frame;
 
     // FIXME: we shouldn't add overhead to every frame by registering these objects when they're not used.
     if (m_frame)
         provideNotification(*m_frame, notificationPresenterImpl());
 }
 
-void WebFrameImpl::initializeAsMainFrame(WebCore::Page* page)
+void WebLocalFrameImpl::initializeAsMainFrame(WebCore::Page* page)
 {
     setWebCoreFrame(LocalFrame::create(&m_frameLoaderClientImpl, &page->frameHost(), 0));
 
     // We must call init() after m_frame is assigned because it is referenced
     // during init().
     m_frame->init();
 }
 
-PassRefPtr<LocalFrame> WebFrameImpl::createChildFrame(const FrameLoadRequest& request, HTMLFrameOwnerElement* ownerElement)
+PassRefPtr<LocalFrame> WebLocalFrameImpl::createChildFrame(const FrameLoadRequest& request, HTMLFrameOwnerElement* ownerElement)
 {
     ASSERT(m_client);
-    WebFrameImpl* webframe = toWebFrameImpl(m_client->createChildFrame(this, request.frameName()));
+    WebLocalFrameImpl* webframe = toWebLocalFrameImpl(m_client->createChildFrame(this, request.frameName()));
     if (!webframe)
         return nullptr;
 
     RefPtr<LocalFrame> childFrame = LocalFrame::create(&webframe->m_frameLoaderClientImpl, frame()->host(), ownerElement);
     webframe->setWebCoreFrame(childFrame);
 
     // FIXME: Using subResourceAttributeName as fallback is not a perfect
     // solution. subResourceAttributeName returns just one attribute name. The
     // element might not have the attribute, and there might be other attributes
     // which can identify the element.
@@ skipping 28 matching lines @@
     // A synchronous navigation (about:blank) would have already processed
     // onload, so it is possible for the frame to have already been destroyed by
     // script in the page.
     // NOTE: m_client will be null if this frame has been detached.
     if (!childFrame->tree().parent())
         return nullptr;
 
     return childFrame.release();
 }
 
-void WebFrameImpl::didChangeContentsSize(const IntSize& size)
+void WebLocalFrameImpl::didChangeContentsSize(const IntSize& size)
 {
     // This is only possible on the main frame.
     if (m_textFinder && m_textFinder->totalMatchCount() > 0) {
         ASSERT(!parent());
         m_textFinder->increaseMarkerVersion();
     }
 }
 
-void WebFrameImpl::createFrameView()
+void WebLocalFrameImpl::createFrameView()
 {
-    TRACE_EVENT0("webkit", "WebFrameImpl::createFrameView");
+    TRACE_EVENT0("webkit", "WebLocalFrameImpl::createFrameView");
 
     ASSERT(frame()); // If frame() doesn't exist, we probably didn't init properly.
 
     WebViewImpl* webView = viewImpl();
     bool isMainFrame = webView->mainFrameImpl()->frame() == frame();
     if (isMainFrame)
         webView->suppressInvalidations(true);
 
     frame()->createView(webView->size(), webView->baseBackgroundColor(), webView->isTransparent());
     if (webView->shouldAutoResize() && isMainFrame)
         frame()->view()->enableAutoSizeMode(true, webView->minAutoSize(), webView->maxAutoSize());
 
     frame()->view()->setInputEventsTransformForEmulation(m_inputEventsOffsetForEmulation, m_inputEventsScaleFactorForEmulation);
 
     if (isMainFrame)
         webView->suppressInvalidations(false);
 }
 
-WebFrameImpl* WebFrameImpl::fromFrame(LocalFrame* frame)
+WebLocalFrameImpl* WebLocalFrameImpl::fromFrame(LocalFrame* frame)
 {
     if (!frame)
         return 0;
     FrameLoaderClient* client = frame->loader().client();
     if (!client || !client->isFrameLoaderClientImpl())
         return 0;
     return toFrameLoaderClientImpl(client)->webFrame();
 }
 
-WebFrameImpl* WebFrameImpl::fromFrameOwnerElement(Element* element)
+WebLocalFrameImpl* WebLocalFrameImpl::fromFrameOwnerElement(Element* element)
 {
-    // FIXME: Why do we check specifically for <iframe> and <frame> here? Why can't we get the WebFrameImpl from an <object> element, for example.
+    // FIXME: Why do we check specifically for <iframe> and <frame> here? Why can't we get the WebLocalFrameImpl from an <object> element, for example.
     if (!isHTMLFrameElementBase(element))
         return 0;
     return fromFrame(toLocalFrame(toHTMLFrameElementBase(element)->contentFrame()));
 }
 
-WebViewImpl* WebFrameImpl::viewImpl() const
+WebViewImpl* WebLocalFrameImpl::viewImpl() const
 {
     if (!frame())
         return 0;
     return WebViewImpl::fromPage(frame()->page());
 }
 
-WebDataSourceImpl* WebFrameImpl::dataSourceImpl() const
+WebDataSourceImpl* WebLocalFrameImpl::dataSourceImpl() const
 {
     return static_cast<WebDataSourceImpl*>(dataSource());
 }
 
-WebDataSourceImpl* WebFrameImpl::provisionalDataSourceImpl() const
+WebDataSourceImpl* WebLocalFrameImpl::provisionalDataSourceImpl() const
 {
     return static_cast<WebDataSourceImpl*>(provisionalDataSource());
 }
 
-void WebFrameImpl::setFindEndstateFocusAndSelection()
+void WebLocalFrameImpl::setFindEndstateFocusAndSelection()
 {
-    WebFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
+    WebLocalFrameImpl* mainFrameImpl = viewImpl()->mainFrameImpl();
 
     if (this != mainFrameImpl->activeMatchFrame())
         return;
 
     if (Range* activeMatch = m_textFinder->activeMatch()) {
         // If the user has set the selection since the match was found, we
         // don't focus anything.
         VisibleSelection selection(frame()->selection().selection());
         if (!selection.isNone())
             return;
@@ skipping 38 matching lines @@
         // active match as the selection (so that when you end the Find session,
         // you'll have the last thing you found highlighted) and make sure that
         // we have nothing focused (otherwise you might have text selected but
         // a link focused, which is weird).
         frame()->selection().setSelection(VisibleSelection(activeMatch));
         frame()->document()->setFocusedElement(nullptr);
 
         // Finally clear the active match, for two reasons:
         // We just finished the find 'session' and we don't want future (potentially
         // unrelated) find 'sessions' operations to start at the same place.
-        // The WebFrameImpl could get reused and the activeMatch could end up pointing
+        // The WebLocalFrameImpl could get reused and the activeMatch could end up pointing
         // to a document that is no longer valid. Keeping an invalid reference around
         // is just asking for trouble.
         m_textFinder->resetActiveMatch();
     }
 }
 
-void WebFrameImpl::didFail(const ResourceError& error, bool wasProvisional)
+void WebLocalFrameImpl::didFail(const ResourceError& error, bool wasProvisional)
 {
     if (!client())
         return;
     WebURLError webError = error;
     if (wasProvisional)
         client()->didFailProvisionalLoad(this, webError);
     else
         client()->didFailLoad(this, webError);
 }
 
-void WebFrameImpl::setCanHaveScrollbars(bool canHaveScrollbars)
+void WebLocalFrameImpl::setCanHaveScrollbars(bool canHaveScrollbars)
 {
     frame()->view()->setCanHaveScrollbars(canHaveScrollbars);
 }
 
-void WebFrameImpl::setInputEventsTransformForEmulation(const IntSize& offset, float contentScaleFactor)
+void WebLocalFrameImpl::setInputEventsTransformForEmulation(const IntSize& offset, float contentScaleFactor)
 {
     m_inputEventsOffsetForEmulation = offset;
     m_inputEventsScaleFactorForEmulation = contentScaleFactor;
     if (frame()->view())
         frame()->view()->setInputEventsTransformForEmulation(m_inputEventsOffsetForEmulation, m_inputEventsScaleFactorForEmulation);
 }
 
-void WebFrameImpl::loadJavaScriptURL(const KURL& url)
+void WebLocalFrameImpl::loadJavaScriptURL(const KURL& url)
 {
     // This is copied from ScriptController::executeScriptIfJavaScriptURL.
     // Unfortunately, we cannot just use that method since it is private, and
-    // it also doesn't quite behave as we require it to for bookmarklets.  The
+    // it also doesn't quite behave as we require it to for bookmarklets. The
     // key difference is that we need to suppress loading the string result
     // from evaluating the JS URL if executing the JS URL resulted in a
-    // location change.  We also allow a JS URL to be loaded even if scripts on
+    // location change. We also allow a JS URL to be loaded even if scripts on
     // the page are otherwise disabled.
 
     if (!frame()->document() || !frame()->page())
         return;
 
     RefPtr<Document> ownerDocument(frame()->document());
 
     // Protect privileged pages against bookmarklets and other javascript manipulations.
     if (SchemeRegistry::shouldTreatURLSchemeAsNotAllowingJavascriptURLs(frame()->document()->url().protocol()))
         return;
 
     String script = decodeURLEscapeSequences(url.string().substring(strlen("javascript:")));
     UserGestureIndicator gestureIndicator(DefinitelyProcessingNewUserGesture);
     ScriptValue result = frame()->script().executeScriptInMainWorldAndReturnValue(ScriptSourceCode(script));
 
     String scriptResult;
     if (!result.toString(scriptResult))
         return;
 
     if (!frame()->navigationScheduler().locationChangePending())
         frame()->document()->loader()->replaceDocument(scriptResult, ownerDocument.get());
 }
 
-void WebFrameImpl::willDetachParent()
+void WebLocalFrameImpl::willDetachParent()
 {
     // Do not expect string scoping results from any frames that got detached
     // in the middle of the operation.
     if (m_textFinder && m_textFinder->scopingInProgress()) {
 
         // There is a possibility that the frame being detached was the only
         // pending one. We need to make sure final replies can be sent.
         m_textFinder->flushCurrentScoping();
 
         m_textFinder->cancelPendingScopingEffort();
     }
 }
 
-WebFrameImpl* WebFrameImpl::activeMatchFrame() const
+WebLocalFrameImpl* WebLocalFrameImpl::activeMatchFrame() const
 {
     ASSERT(!parent());
 
     if (m_textFinder)
         return m_textFinder->activeMatchFrame();
     return 0;
 }
 
-WebCore::Range* WebFrameImpl::activeMatch() const
+WebCore::Range* WebLocalFrameImpl::activeMatch() const
 {
     if (m_textFinder)
         return m_textFinder->activeMatch();
     return 0;
 }
 
-TextFinder& WebFrameImpl::ensureTextFinder()
+TextFinder& WebLocalFrameImpl::ensureTextFinder()
 {
     if (!m_textFinder)
         m_textFinder = TextFinder::create(*this);
 
     return *m_textFinder;
 }
 
-void WebFrameImpl::invalidateScrollbar() const
+void WebLocalFrameImpl::invalidateScrollbar() const
 {
     ASSERT(frame() && frame()->view());
     FrameView* view = frame()->view();
     // Invalidate the vertical scroll bar region for the view.
     Scrollbar* scrollbar = view->verticalScrollbar();
     if (scrollbar)
         scrollbar->invalidate();
 }
 
-void WebFrameImpl::invalidateAll() const
+void WebLocalFrameImpl::invalidateAll() const
 {
     ASSERT(frame() && frame()->view());
     FrameView* view = frame()->view();
     view->invalidateRect(view->frameRect());
     invalidateScrollbar();
 }
 
 } // namespace blink