Rename WebFrameImpl to WebLocalFrameImpl.

Source/web/ChromeClientImpl.cpp

 /*
  * Copyright (C) 2009 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 29 matching lines @@
 #include "HTMLNames.h"
 #include "PopupMenuChromium.h"
 #include "RuntimeEnabledFeatures.h"
 #include "WebAXObject.h"
 #include "WebAutofillClient.h"
 #include "WebColorChooser.h"
 #include "WebColorSuggestion.h"
 #include "WebConsoleMessage.h"
 #include "WebFileChooserCompletionImpl.h"
 #include "WebFrameClient.h"
-#include "WebFrameImpl.h"
 #include "WebInputElement.h"
 #include "WebInputEvent.h"
 #include "WebInputEventConversion.h"
 #include "WebKit.h"
+#include "WebLocalFrameImpl.h"
 #include "WebNode.h"
 #include "WebPasswordGeneratorClient.h"
 #include "WebPlugin.h"
 #include "WebPluginContainerImpl.h"
 #include "WebPopupMenuImpl.h"
 #include "WebPopupMenuInfo.h"
 #include "WebSettings.h"
 #include "WebSettingsImpl.h"
 #include "WebTextDirection.h"
 #include "WebUserGestureIndicator.h"
@@ skipping 143 matching lines @@
         // This cast must be valid because of the isLink() check.
         hitTest.setURLElement(toElement(node));
         if (hitTest.isLiveLink())
             focusURL = hitTest.absoluteLinkURL();
     }
     m_webView->client()->setKeyboardFocusURL(focusURL);
 }
 
 void ChromeClientImpl::focusedFrameChanged(WebCore::LocalFrame* frame)
 {
-    WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
+    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe && webframe->client())
         webframe->client()->frameFocused();
 }
 
 Page* ChromeClientImpl::createWindow(LocalFrame* frame, const FrameLoadRequest& r, const WindowFeatures& features,
     NavigationPolicy navigationPolicy, ShouldSendReferrer shouldSendReferrer)
 {
     if (!m_webView->client())
         return 0;
 
     WebNavigationPolicy policy = static_cast<WebNavigationPolicy>(navigationPolicy);
     if (policy == WebNavigationPolicyIgnore)
         policy = getNavigationPolicy();
 
     ASSERT(frame->document());
     DocumentFullscreen::webkitCancelFullScreen(*frame->document());
 
     WebViewImpl* newView = toWebViewImpl(
-        m_webView->client()->createView(WebFrameImpl::fromFrame(frame), WrappedResourceRequest(r.resourceRequest()), features, r.frameName(), policy, shouldSendReferrer == NeverSendReferrer));
+        m_webView->client()->createView(WebLocalFrameImpl::fromFrame(frame), WrappedResourceRequest(r.resourceRequest()), features, r.frameName(), policy, shouldSendReferrer == NeverSendReferrer));
     if (!newView)
         return 0;
     return newView->page();
 }
 
 static inline void updatePolicyForEvent(const WebInputEvent* inputEvent, NavigationPolicy* policy)
 {
     if (!inputEvent || inputEvent->type != WebInputEvent::MouseUp)
         return;
 
@@ skipping 83 matching lines @@
 }
 
 bool ChromeClientImpl::statusbarVisible()
 {
     return m_statusbarVisible;
 }
 
 void ChromeClientImpl::setScrollbarsVisible(bool value)
 {
     m_scrollbarsVisible = value;
-    WebFrameImpl* webFrame = toWebFrameImpl(m_webView->mainFrame());
+    WebLocalFrameImpl* webFrame = toWebLocalFrameImpl(m_webView->mainFrame());
     if (webFrame)
         webFrame->setCanHaveScrollbars(value);
 }
 
 bool ChromeClientImpl::scrollbarsVisible()
 {
     return m_scrollbarsVisible;
 }
 
 void ChromeClientImpl::setMenubarVisible(bool value)
 {
     m_menubarVisible = value;
 }
 
 bool ChromeClientImpl::menubarVisible()
 {
     return m_menubarVisible;
 }
 
 void ChromeClientImpl::setResizable(bool value)
 {
     m_resizable = value;
 }
 
 bool ChromeClientImpl::shouldReportDetailedMessageForSource(const String& url)
 {
-    WebFrameImpl* webframe = m_webView->mainFrameImpl();
+    WebLocalFrameImpl* webframe = m_webView->mainFrameImpl();
     return webframe->client() && webframe->client()->shouldReportDetailedMessageForSource(url);
 }
 
 void ChromeClientImpl::addMessageToConsole(LocalFrame* localFrame, MessageSource source, MessageLevel level, const String& message, unsigned lineNumber, const String& sourceID, const String& stackTrace)
 {
-    WebFrameImpl* frame = WebFrameImpl::fromFrame(localFrame);
+    WebLocalFrameImpl* frame = WebLocalFrameImpl::fromFrame(localFrame);
     if (frame && frame->client()) {
         frame->client()->didAddMessageToConsole(
             WebConsoleMessage(static_cast<WebConsoleMessage::Level>(level), message),
             sourceID,
             lineNumber,
             stackTrace);
     }
 }
 
 bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel()
 {
     return !!m_webView->client();
 }
 
 bool ChromeClientImpl::runBeforeUnloadConfirmPanel(const String& message, LocalFrame* frame)
 {
-    WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
+    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
 
     bool isReload = false;
     WebDataSource* ds = webframe->provisionalDataSource();
     if (ds)
         isReload = (ds->navigationType() == blink::WebNavigationTypeReload);
 
     if (webframe->client())
         return webframe->client()->runModalBeforeUnloadDialog(isReload, message);
     return false;
 }
 
 void ChromeClientImpl::closeWindowSoon()
 {
     // Make sure this Page can no longer be found by JS.
     Page::ordinaryPages().remove(m_webView->page());
 
     // Make sure that all loading is stopped.  Ensures that JS stops executing!
     m_webView->mainFrame()->stopLoading();
 
     if (m_webView->client())
         m_webView->client()->closeWidgetSoon();
 }
 
 // Although a LocalFrame is passed in, we don't actually use it, since we
 // already know our own m_webView.
 void ChromeClientImpl::runJavaScriptAlert(LocalFrame* frame, const String& message)
 {
-    WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
+    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe->client()) {
         if (WebUserGestureIndicator::isProcessingUserGesture())
             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
         webframe->client()->runModalAlertDialog(message);
     }
 }
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptConfirm(LocalFrame* frame, const String& message)
 {
-    WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
+    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe->client()) {
         if (WebUserGestureIndicator::isProcessingUserGesture())
             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
         return webframe->client()->runModalConfirmDialog(message);
     }
     return false;
 }
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptPrompt(LocalFrame* frame,
                                            const String& message,
                                            const String& defaultValue,
                                            String& result)
 {
-    WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
+    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     if (webframe->client()) {
         if (WebUserGestureIndicator::isProcessingUserGesture())
             WebUserGestureIndicator::currentUserGestureToken().setJavascriptPrompt();
         WebString actualValue;
         bool ok = webframe->client()->runModalPromptDialog(
             message,
             defaultValue,
             &actualValue);
         if (ok)
             result = actualValue;
@@ skipping 72 matching lines @@
 
 WebScreenInfo ChromeClientImpl::screenInfo() const
 {
     return m_webView->client() ? m_webView->client()->screenInfo() : WebScreenInfo();
 }
 
 void ChromeClientImpl::contentsSizeChanged(LocalFrame* frame, const IntSize& size) const
 {
     m_webView->didChangeContentsSize();
 
-    WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
+    WebLocalFrameImpl* webframe = WebLocalFrameImpl::fromFrame(frame);
     webframe->didChangeContentsSize(size);
     if (webframe->client())
         webframe->client()->didChangeContentsSize(webframe, size);
 
     frame->loader().restoreScrollPositionAndViewState();
 }
 
 void ChromeClientImpl::deviceOrPageScaleFactorChanged() const
 {
     m_webView->deviceOrPageScaleFactorChanged();
 }
 
 void ChromeClientImpl::layoutUpdated(LocalFrame* frame) const
 {
-    m_webView->layoutUpdated(WebFrameImpl::fromFrame(frame));
+    m_webView->layoutUpdated(WebLocalFrameImpl::fromFrame(frame));
 }
 
 void ChromeClientImpl::mouseDidMoveOverElement(
     const HitTestResult& result, unsigned modifierFlags)
 {
     if (!m_webView->client())
         return;
 
     WebURL url;
     // Find out if the mouse is over a link, and if so, let our UI know...
@@ skipping 27 matching lines @@
 }
 
 void ChromeClientImpl::dispatchViewportPropertiesDidChange(const ViewportDescription& description) const
 {
     m_webView->updatePageDefinedViewportConstraints(description);
 }
 
 void ChromeClientImpl::print(LocalFrame* frame)
 {
     if (m_webView->client())
-        m_webView->client()->printPage(WebFrameImpl::fromFrame(frame));
+        m_webView->client()->printPage(WebLocalFrameImpl::fromFrame(frame));
 }
 
 PassOwnPtr<ColorChooser> ChromeClientImpl::createColorChooser(LocalFrame* frame, ColorChooserClient* chooserClient, const Color&)
 {
     OwnPtr<ColorChooserUIController> controller;
     if (RuntimeEnabledFeatures::pagePopupEnabled())
         controller = adoptPtr(new ColorChooserPopupUIController(frame, this, chooserClient));
     else
         controller = adoptPtr(new ColorChooserUIController(frame, chooserClient));
     controller->openUI();
@@ skipping 83 matching lines @@
 }
 
 String ChromeClientImpl::acceptLanguages()
 {
     return m_webView->client()->acceptLanguages();
 }
 
 bool ChromeClientImpl::paintCustomOverhangArea(GraphicsContext* context, const IntRect& horizontalOverhangArea, const IntRect& verticalOverhangArea, const IntRect& dirtyRect)
 {
     LocalFrame* frame = m_webView->mainFrameImpl()->frame();
-    WebPluginContainerImpl* pluginContainer = WebFrameImpl::pluginContainerFromFrame(frame);
+    WebPluginContainerImpl* pluginContainer = WebLocalFrameImpl::pluginContainerFromFrame(frame);
     if (pluginContainer)
         return pluginContainer->paintCustomOverhangArea(context, horizontalOverhangArea, verticalOverhangArea, dirtyRect);
     return false;
 }
 
 GraphicsLayerFactory* ChromeClientImpl::graphicsLayerFactory() const
 {
     return m_webView->graphicsLayerFactory();
 }
 
@@ skipping 147 matching lines @@
     if (!m_webView->autofillClient())
         return;
     m_webView->autofillClient()->textFieldDidReceiveKeyDown(WebInputElement(&inputElement), WebKeyboardEventBuilder(event));
 }
 
 // FIXME: Remove this code once we have input routing in the browser
 // process. See http://crbug.com/339659.
 void ChromeClientImpl::forwardInputEvent(
     WebCore::Frame* frame, WebCore::Event* event)
 {
-    WebFrameImpl* webFrame = WebFrameImpl::fromFrame(toLocalFrameTemporary(frame));
+    WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(toLocalFrameTemporary(frame));
 
     // This is only called when we have out-of-process iframes, which
     // need to forward input events across processes.
     // FIXME: Add a check for out-of-process iframes enabled.
     if (event->isKeyboardEvent()) {
         WebKeyboardEventBuilder webEvent(*static_cast<WebCore::KeyboardEvent*>(event));
         webFrame->client()->forwardInputEvent(&webEvent);
     } else if (event->isMouseEvent()) {
         WebMouseEventBuilder webEvent(webFrame->frameView(), frame->ownerRenderer(), *static_cast<WebCore::MouseEvent*>(event));
         // Internal Blink events should not be forwarded.
@@ skipping 47 matching lines @@
 {
     return static_cast<NavigatorContentUtilsClient::CustomHandlersState>(m_webView->client()->isProtocolHandlerRegistered(scheme, baseURL, url));
 }
 
 void NavigatorContentUtilsClientImpl::unregisterProtocolHandler(const String& scheme, const WebCore::KURL& baseURL, const WebCore::KURL& url)
 {
     m_webView->client()->unregisterProtocolHandler(scheme, baseURL, url);
 }
 
 } // namespace blink