Moves webview_impl.cc, webframe_impl.cc and webframeloaderclient_impl.cc into...

webkit/api/src/ChromeClientImpl.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 38 matching lines @@
 #include "NotificationPresenterImpl.h"
 #include "Page.h"
 #include "PopupMenuChromium.h"
 #include "ScriptController.h"
 #if USE(V8)
 #include "V8Proxy.h"
 #endif
 #include "WebAccessibilityObject.h"
 #include "WebConsoleMessage.h"
 #include "WebCursorInfo.h"
-#include "WebFileChooserCompletion.h"
+#include "WebFileChooserCompletionImpl.h"
 #include "WebFrameClient.h"
+#include "WebFrameImpl.h"
 #include "WebInputEvent.h"
 #include "WebKit.h"
+#include "WebPopupMenuImpl.h"
 #include "WebPopupMenuInfo.h"
 #include "WebRect.h"
 #include "WebTextDirection.h"
 #include "WebURLRequest.h"
 #include "WebViewClient.h"
-#include "WebFileChooserCompletionImpl.h"
-#include "WebPopupMenuImpl.h"
+#include "WebViewImpl.h"
 #include "WindowFeatures.h"
 #include "WrappedResourceRequest.h"
 
-// FIXME: Remove these once they move out of glue/.
-#include "webkit/glue/webframe_impl.h"
-#include "webkit/glue/webview_impl.h"
-
 using namespace WebCore;
 
 namespace WebKit {
 
 ChromeClientImpl::ChromeClientImpl(WebViewImpl* webView)
     : m_webView(webView)
     , m_toolbarsVisible(true)
     , m_statusbarVisible(true)
     , m_scrollbarsVisible(true)
     , m_menubarVisible(true)
@@ skipping 54 matching lines @@
 
 void ChromeClientImpl::focus()
 {
     if (!m_webView->client())
         return;
 
     m_webView->client()->didFocus();
 
     // If accessibility is enabled, we should notify assistive technology that
     // the active AccessibilityObject changed.
-    const Frame* frame = m_webView->GetFocusedWebCoreFrame();
+    const Frame* frame = m_webView->focusedWebCoreFrame();
     if (!frame)
         return;
 
     Document* doc = frame->document();
 
     if (doc && doc->axObjectCache()->accessibilityEnabled()) {
-        Node* focusedNode = m_webView->GetFocusedNode();
+        Node* focusedNode = m_webView->focusedWebCoreNode();
 
         if (!focusedNode) {
             // Could not retrieve focused Node.
             return;
         }
 
         // Retrieve the focused AccessibilityObject.
         AccessibilityObject* focusedAccObj =
             doc->axObjectCache()->getOrCreate(focusedNode->renderer());
 
@@ skipping 26 matching lines @@
         m_webView->client()->focusNext();
 }
 
 Page* ChromeClientImpl::createWindow(
     Frame* frame, const FrameLoadRequest& r, const WindowFeatures& features)
 {
     if (!m_webView->client())
         return 0;
 
     WebViewImpl* newView = static_cast<WebViewImpl*>(
-        m_webView->client()->createView(WebFrameImpl::FromFrame(frame)));
+        m_webView->client()->createView(WebFrameImpl::fromFrame(frame)));
     if (!newView)
         return 0;
 
     // The request is empty when we are just being asked to open a blank window.
     // This corresponds to window.open(""), for example.
     if (!r.resourceRequest().isEmpty()) {
         WrappedResourceRequest request(r.resourceRequest());
-        newView->main_frame()->loadRequest(request);
+        newView->mainFrame()->loadRequest(request);
     }
 
     return newView->page();
 }
 
-static inline bool CurrentEventShouldCauseBackgroundTab(const WebInputEvent* inputEvent)
+static inline bool currentEventShouldCauseBackgroundTab(const WebInputEvent* inputEvent)
 {
     if (!inputEvent)
         return false;
 
     if (inputEvent->type != WebInputEvent::MouseUp)
         return false;
 
     const WebMouseEvent* mouseEvent = static_cast<const WebMouseEvent*>(inputEvent);
 
     WebNavigationPolicy policy;
     unsigned short buttonNumber;
     switch (mouseEvent->button) {
     case WebMouseEvent::ButtonLeft:
         buttonNumber = 0;
         break;
     case WebMouseEvent::ButtonMiddle:
         buttonNumber = 1;
         break;
     case WebMouseEvent::ButtonRight:
         buttonNumber = 2;
         break;
     default:
         return false;
     }
     bool ctrl = mouseEvent->modifiers & WebMouseEvent::ControlKey;
     bool shift = mouseEvent->modifiers & WebMouseEvent::ShiftKey;
     bool alt = mouseEvent->modifiers & WebMouseEvent::AltKey;
     bool meta = mouseEvent->modifiers & WebMouseEvent::MetaKey;
 
-    if (!WebViewImpl::NavigationPolicyFromMouseEvent(buttonNumber, ctrl, shift, alt, meta, &policy))
+    if (!WebViewImpl::navigationPolicyFromMouseEvent(buttonNumber, ctrl, shift, alt, meta, &policy))
         return false;
 
     return policy == WebNavigationPolicyNewBackgroundTab;
 }
 
 void ChromeClientImpl::show()
 {
     if (!m_webView->client())
         return;
 
     // If our default configuration was modified by a script or wasn't
     // created by a user gesture, then show as a popup. Else, let this
     // new window be opened as a toplevel window.
     bool asPopup =
         !m_toolbarsVisible ||
         !m_statusbarVisible ||
         !m_scrollbarsVisible ||
         !m_menubarVisible ||
         !m_resizable;
 
     WebNavigationPolicy policy = WebNavigationPolicyNewForegroundTab;
     if (asPopup)
         policy = WebNavigationPolicyNewPopup;
-    if (CurrentEventShouldCauseBackgroundTab(WebViewImpl::current_input_event()))
+    if (currentEventShouldCauseBackgroundTab(WebViewImpl::currentInputEvent()))
         policy = WebNavigationPolicyNewBackgroundTab;
 
     m_webView->client()->show(policy);
 }
 
 bool ChromeClientImpl::canRunModal()
 {
     return m_webView->client() != 0;
 }
 
@@ skipping 21 matching lines @@
 bool ChromeClientImpl::statusbarVisible()
 {
     return m_statusbarVisible;
 }
 
 void ChromeClientImpl::setScrollbarsVisible(bool value)
 {
     m_scrollbarsVisible = value;
     WebFrameImpl* web_frame = static_cast<WebFrameImpl*>(m_webView->mainFrame());
     if (web_frame)
-        web_frame->SetAllowsScrolling(value);
+        web_frame->setAllowsScrolling(value);
 }
 
 bool ChromeClientImpl::scrollbarsVisible()
 {
     return m_scrollbarsVisible;
 }
 
 void ChromeClientImpl::setMenubarVisible(bool value)
 {
     m_menubarVisible = value;
@@ skipping 26 matching lines @@
 
 bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel()
 {
     return m_webView->client() != 0;
 }
 
 bool ChromeClientImpl::runBeforeUnloadConfirmPanel(const String& message, Frame* frame)
 {
     if (m_webView->client()) {
         return m_webView->client()->runModalBeforeUnloadDialog(
-            WebFrameImpl::FromFrame(frame), message);
+            WebFrameImpl::fromFrame(frame), message);
     }
     return false;
 }
 
 void ChromeClientImpl::closeWindowSoon()
 {
     // Make sure this Page can no longer be found by JS.
     m_webView->page()->setGroupName(String());
 
     // 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 Frame is passed in, we don't actually use it, since we
 // already know our own m_webView.
 void ChromeClientImpl::runJavaScriptAlert(Frame* frame, const String& message)
 {
     if (m_webView->client()) {
 #if USE(V8)
         // Before showing the JavaScript dialog, we give the proxy implementation
         // a chance to process any pending console messages.
         V8Proxy::processConsoleMessages();
 #endif
         m_webView->client()->runModalAlertDialog(
-            WebFrameImpl::FromFrame(frame), message);
+            WebFrameImpl::fromFrame(frame), message);
     }
 }
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptConfirm(Frame* frame, const String& message)
 {
     if (m_webView->client()) {
         return m_webView->client()->runModalConfirmDialog(
-            WebFrameImpl::FromFrame(frame), message);
+            WebFrameImpl::fromFrame(frame), message);
     }
     return false;
 }
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptPrompt(Frame* frame,
                                            const String& message,
                                            const String& defaultValue,
                                            String& result)
 {
     if (m_webView->client()) {
         WebString actualValue;
         bool ok = m_webView->client()->runModalPromptDialog(
-            WebFrameImpl::FromFrame(frame),
+            WebFrameImpl::fromFrame(frame),
             message,
             defaultValue,
             &actualValue);
         if (ok)
             result = actualValue;
         return ok;
     }
     return false;
 }
 
@@ skipping 61 matching lines @@
     if (m_webView->client()) {
         WebRect windowRect = m_webView->client()->windowRect();
         screenRect.move(windowRect.x, windowRect.y);
     }
 
     return screenRect;
 }
 
 void ChromeClientImpl::contentsSizeChanged(Frame* frame, const IntSize& size) const
 {
-    WebFrameImpl* webframe = WebFrameImpl::FromFrame(frame);
+    WebFrameImpl* webframe = WebFrameImpl::fromFrame(frame);
     if (webframe->client())
         webframe->client()->didChangeContentsSize(webframe, size);
 }
 
 void ChromeClientImpl::scrollbarsModeDidChange() const
 {
 }
 
 void ChromeClientImpl::mouseDidMoveOverElement(
     const HitTestResult& result, unsigned modifierFlags)
@@ skipping 14 matching lines @@
     WebTextDirection textDirection = (dir == RTL) ?
         WebTextDirectionRightToLeft :
         WebTextDirectionLeftToRight;
     m_webView->client()->setToolTipText(
         tooltipText, textDirection);
 }
 
 void ChromeClientImpl::print(Frame* frame)
 {
     if (m_webView->client())
-        m_webView->client()->printPage(WebFrameImpl::FromFrame(frame));
+        m_webView->client()->printPage(WebFrameImpl::fromFrame(frame));
 }
 
 void ChromeClientImpl::exceededDatabaseQuota(Frame* frame, const String& databaseName)
 {
     // set a reasonable quota for now -- 5Mb should be enough for anybody
     // TODO(dglazkov): this should be configurable
     SecurityOrigin* origin = frame->document()->securityOrigin();
     DatabaseTracker::tracker().setQuota(origin, 1024 * 1024 * 5);
 }
 
@@ skipping 65 matching lines @@
     // Currently, Widget::setCursor is always called after this function in
     // EventHandler.cpp and since we don't want that we set a flag indicating
     // that the next SetCursor call is to be ignored.
     m_ignoreNextSetCursor = true;
 }
 
 void ChromeClientImpl::formStateDidChange(const Node* node)
 {
     // The current history item is not updated yet.  That happens lazily when
     // WebFrame::currentHistoryItem is requested.
-    WebFrameImpl* webframe = WebFrameImpl::FromFrame(node->document()->frame());
+    WebFrameImpl* webframe = WebFrameImpl::fromFrame(node->document()->frame());
     if (webframe->client())
         webframe->client()->didUpdateCurrentHistoryItem(webframe);
 }
 
 void ChromeClientImpl::getPopupMenuInfo(PopupContainer* popupContainer,
                                         WebPopupMenuInfo* info)
 {
     const Vector<PopupItem*>& inputItems = popupContainer->popupData();
 
     WebVector<WebPopupMenuInfo::Item> outputItems(inputItems.size());
@@ skipping 21 matching lines @@
     }
 
     info->itemHeight = popupContainer->menuItemHeight();
     info->selectedIndex = popupContainer->selectedIndex();
     info->items.swap(outputItems);
 }
 
 #if ENABLE(NOTIFICATIONS)
 NotificationPresenter* ChromeClientImpl::notificationPresenter() const
 {
-    return m_webView->GetNotificationPresenter();
+    return m_webView->notificationPresenterImpl();
 }
 #endif
 
 } // namespace WebKit