Convert types in WebFrameLoaderClientImpl in preparation for moving...

webkit/glue/chrome_client_impl.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 
 #include "AccessibilityObject.h"
 #include "AXObjectCache.h"
 #include "CharacterNames.h"
 #include "Console.h"
@@ skipping 10 matching lines @@
 #include "Node.h"
 #include "Page.h"
 #include "PopupMenuChromium.h"
 #include "ScriptController.h"
 #include "WindowFeatures.h"
 #if USE(V8)
 #include "V8Proxy.h"
 #endif
 #undef LOG
 
-#include "googleurl/src/gurl.h"
 #include "webkit/api/public/WebConsoleMessage.h"
 #include "webkit/api/public/WebCursorInfo.h"
 #include "webkit/api/public/WebFileChooserCompletion.h"
 #include "webkit/api/public/WebFrameClient.h"
 #include "webkit/api/public/WebInputEvent.h"
 #include "webkit/api/public/WebKit.h"
 #include "webkit/api/public/WebPopupMenuInfo.h"
 #include "webkit/api/public/WebRect.h"
 #include "webkit/api/public/WebTextDirection.h"
 #include "webkit/api/public/WebURLRequest.h"
@@ skipping 40 matching lines @@
 }
 
 ChromeClientImpl::~ChromeClientImpl() {
 }
 
 void ChromeClientImpl::chromeDestroyed() {
   // Our lifetime is bound to the WebViewImpl.
 }
 
 void ChromeClientImpl::setWindowRect(const WebCore::FloatRect& r) {
-  WebViewDelegate* delegate = webview_->delegate();
-  if (delegate) {
-    delegate->setWindowRect(
+  if (webview_->client()) {
+    webview_->client()->setWindowRect(
         webkit_glue::IntRectToWebRect(WebCore::IntRect(r)));
   }
 }
 
 WebCore::FloatRect ChromeClientImpl::windowRect() {
   WebRect rect;
-  if (webview_->delegate()) {
-    rect = webview_->delegate()->rootWindowRect();
+  if (webview_->client()) {
+    rect = webview_->client()->rootWindowRect();
   } else {
     // These numbers will be fairly wrong. The window's x/y coordinates will
     // be the top left corner of the screen and the size will be the content
     // size instead of the window size.
     rect.width = webview_->size().width;
     rect.height = webview_->size().height;
   }
   return WebCore::FloatRect(webkit_glue::WebRectToIntRect(rect));
 }
 
 WebCore::FloatRect ChromeClientImpl::pageRect() {
   // We hide the details of the window's border thickness from the web page by
   // simple re-using the window position here.  So, from the point-of-view of
   // the web page, the window has no border.
   return windowRect();
 }
 
 float ChromeClientImpl::scaleFactor() {
   // This is supposed to return the scale factor of the web page. It looks like
   // the implementor of the graphics layer is responsible for doing most of the
   // operations associated with scaling. However, this value is used ins some
   // cases by WebCore. For example, this is used as a scaling factor in canvas
   // so that things drawn in it are scaled just like the web page is.
   //
   // We don't currently implement scaling, so just return 1.0 (no scaling).
   return 1.0;
 }
 
 void ChromeClientImpl::focus() {
-  WebViewDelegate* delegate = webview_->delegate();
-  if (delegate) {
-    delegate->didFocus();
+  if (!webview_->client())
+    return;
 
-    // If accessibility is enabled, we should notify assistive technology that
-    // the active AccessibilityObject changed.
-    const WebCore::Frame* frame = webview_->GetFocusedWebCoreFrame();
-    if (!frame)
+  webview_->client()->didFocus();
+
+  // If accessibility is enabled, we should notify assistive technology that
+  // the active AccessibilityObject changed.
+  const WebCore::Frame* frame = webview_->GetFocusedWebCoreFrame();
+  if (!frame)
+    return;
+
+  WebCore::Document* doc = frame->document();
+
+  if (doc && doc->axObjectCache()->accessibilityEnabled()) {
+    WebCore::Node* focused_node = webview_->GetFocusedNode();
+
+    if (!focused_node) {
+      // Could not retrieve focused Node.
       return;
+    }
 
-    WebCore::Document* doc = frame->document();
+    // Retrieve the focused AccessibilityObject.
+    WebCore::AccessibilityObject* focused_acc_obj =
+        doc->axObjectCache()->getOrCreate(focused_node->renderer());
 
-    if (doc && doc->axObjectCache()->accessibilityEnabled()) {
-      WebCore::Node* focused_node = webview_->GetFocusedNode();
-
-      if (!focused_node) {
-        // Could not retrieve focused Node.
-        return;
-      }
-
-      // Retrieve the focused AccessibilityObject.
-      WebCore::AccessibilityObject* focused_acc_obj =
-          doc->axObjectCache()->getOrCreate(focused_node->renderer());
-
-      // Alert assistive technology that focus changed.
-      if (focused_acc_obj)
-        delegate->FocusAccessibilityObject(focused_acc_obj);
-    }
+    // Alert assistive technology that focus changed.
+    if (focused_acc_obj)
+      webview_->delegate()->FocusAccessibilityObject(focused_acc_obj);
   }
 }
 
 void ChromeClientImpl::unfocus() {
-  WebViewDelegate* delegate = webview_->delegate();
-  if (delegate)
-    delegate->didBlur();
+  if (webview_->client())
+    webview_->client()->didBlur();
 }
 
 bool ChromeClientImpl::canTakeFocus(WebCore::FocusDirection) {
   // For now the browser can always take focus if we're not running layout
   // tests.
   return !WebKit::layoutTestMode();
 }
 
 void ChromeClientImpl::takeFocus(WebCore::FocusDirection direction) {
   if (!webview_->client())
@@ skipping 84 matching lines @@
       policy = WebKit::WebNavigationPolicyNewPopup;
     if (CurrentEventShouldCauseBackgroundTab(
           WebViewImpl::current_input_event()))
       policy = WebKit::WebNavigationPolicyNewBackgroundTab;
 
     delegate->show(policy);
   }
 }
 
 bool ChromeClientImpl::canRunModal() {
-  return webview_->delegate() != NULL;
+  return webview_->client() != NULL;
 }
 
 void ChromeClientImpl::runModal() {
-  WebViewDelegate* delegate = webview_->delegate();
-  if (delegate)
-    delegate->runModal();
+  if (webview_->client())
+    webview_->client()->runModal();
 }
 
 void ChromeClientImpl::setToolbarsVisible(bool value) {
   toolbars_visible_ = value;
 }
 
 bool ChromeClientImpl::toolbarsVisible() {
   return toolbars_visible_;
 }
 
@@ skipping 37 matching lines @@
   if (webview_->client()) {
     webview_->client()->didAddMessageToConsole(
         WebConsoleMessage(static_cast<WebConsoleMessage::Level>(level),
                           webkit_glue::StringToWebString(message)),
         webkit_glue::StringToWebString(source_id),
         line_no);
   }
 }
 
 bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel() {
-  return webview_->delegate() != NULL;
+  return webview_->client() != NULL;
 }
 
 bool ChromeClientImpl::runBeforeUnloadConfirmPanel(
     const WebCore::String& message,
     WebCore::Frame* frame) {
   if (webview_->client()) {
     return webview_->client()->runModalBeforeUnloadDialog(
         WebFrameImpl::FromFrame(frame),
         webkit_glue::StringToWebString(message));
   }
@@ skipping 68 matching lines @@
   // TODO(mbelshe): implement me
   return false;
 }
 
 bool ChromeClientImpl::tabsToLinks() const {
   return webview_->tabsToLinks();
 }
 
 WebCore::IntRect ChromeClientImpl::windowResizerRect() const {
   WebCore::IntRect result;
-  if (webview_->delegate()) {
+  if (webview_->client()) {
     result = webkit_glue::WebRectToIntRect(
-        webview_->delegate()->windowResizerRect());
+        webview_->client()->windowResizerRect());
   }
   return result;
 }
 
 void ChromeClientImpl::repaint(
     const WebCore::IntRect& paint_rect, bool content_changed, bool immediate,
     bool repaint_content_only) {
   // Ignore spurious calls.
   if (!content_changed || paint_rect.isEmpty())
     return;
-  WebViewDelegate* delegate = webview_->delegate();
-  if (delegate)
-    delegate->didInvalidateRect(webkit_glue::IntRectToWebRect(paint_rect));
+  if (webview_->client()) {
+    webview_->client()->didInvalidateRect(
+        webkit_glue::IntRectToWebRect(paint_rect));
+  }
 }
 
 void ChromeClientImpl::scroll(
     const WebCore::IntSize& scroll_delta, const WebCore::IntRect& scroll_rect,
     const WebCore::IntRect& clip_rect) {
-  WebViewDelegate* delegate = webview_->delegate();
-  if (delegate) {
+  if (webview_->client()) {
     int dx = scroll_delta.width();
     int dy = scroll_delta.height();
-    delegate->didScrollRect(
+    webview_->client()->didScrollRect(
         dx, dy, webkit_glue::IntRectToWebRect(clip_rect));
   }
 }
 
 WebCore::IntPoint ChromeClientImpl::screenToWindow(
     const WebCore::IntPoint&) const {
   NOTIMPLEMENTED();
   return WebCore::IntPoint();
 }
 
 WebCore::IntRect ChromeClientImpl::windowToScreen(
     const WebCore::IntRect& rect) const {
   WebCore::IntRect screen_rect(rect);
 
-  WebViewDelegate* delegate = webview_->delegate();
-  if (delegate) {
-    WebRect window_rect = delegate->windowRect();
+  if (webview_->client()) {
+    WebRect window_rect = webview_->client()->windowRect();
     screen_rect.move(window_rect.x, window_rect.y);
   }
 
   return screen_rect;
 }
 
 void ChromeClientImpl::contentsSizeChanged(WebCore::Frame* frame, const
     WebCore::IntSize& size) const {
   WebFrameImpl* webframe = WebFrameImpl::FromFrame(frame);
   if (webframe->client()) {
@@ skipping 85 matching lines @@
   static_cast<WebPopupMenuImpl*>(webwidget)->Init(
       popup_container, webkit_glue::IntRectToWebRect(bounds));
 }
 
 void ChromeClientImpl::SetCursor(const WebCursorInfo& cursor) {
   if (ignore_next_set_cursor_) {
     ignore_next_set_cursor_ = false;
     return;
   }
 
-  WebViewDelegate* delegate = webview_->delegate();
-  if (delegate)
-    delegate->didChangeCursor(cursor);
+  if (webview_->client())
+    webview_->client()->didChangeCursor(cursor);
 }
 
 void ChromeClientImpl::SetCursorForPlugin(const WebCursorInfo& cursor) {
   SetCursor(cursor);
   // 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.
   ignore_next_set_cursor_ = true;
 }
 
@@ skipping 36 matching lines @@
   info->itemHeight = popup_container->menuItemHeight();
   info->selectedIndex = popup_container->selectedIndex();
   info->items.swap(output_items);
 }
 
 #if ENABLE(NOTIFICATIONS)
 WebCore::NotificationPresenter* ChromeClientImpl::notificationPresenter() const {
   return webview_->GetNotificationPresenter();
 }
 #endif