Use WebWidget from the WebKit API. This change also makes...

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 "base/compiler_specific.h"
 
 MSVC_PUSH_WARNING_LEVEL(0);
 #include "AccessibilityObject.h"
@@ skipping 28 matching lines @@
 #include "webkit/api/public/WebCursorInfo.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/WebURLRequest.h"
 #include "webkit/api/src/WrappedResourceRequest.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webframe_impl.h"
 #include "webkit/glue/webkit_glue.h"
+#include "webkit/glue/webpopupmenu_impl.h"
 #include "webkit/glue/webview_delegate.h"
 #include "webkit/glue/webview_impl.h"
-#include "webkit/glue/webwidget_impl.h"
 
 using WebCore::PopupContainer;
 using WebCore::PopupItem;
 
 using WebKit::WebCursorInfo;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
+using WebKit::WebNavigationPolicy;
 using WebKit::WebPopupMenuInfo;
 using WebKit::WebRect;
 using WebKit::WebURLRequest;
 using WebKit::WebVector;
+using WebKit::WebWidget;
 using WebKit::WrappedResourceRequest;
 
 // Callback class that's given to the WebViewDelegate during a file choose
 // operation.
 class WebFileChooserCallbackImpl : public WebFileChooserCallback {
  public:
   WebFileChooserCallbackImpl(PassRefPtr<WebCore::FileChooser> file_chooser)
       : file_chooser_(file_chooser) {
   }
 
@@ skipping 30 matching lines @@
 ChromeClientImpl::~ChromeClientImpl() {
 }
 
 void ChromeClientImpl::chromeDestroyed() {
   delete this;
 }
 
 void ChromeClientImpl::setWindowRect(const WebCore::FloatRect& r) {
   WebViewDelegate* delegate = webview_->delegate();
   if (delegate) {
-    WebCore::IntRect ir(r);
-    delegate->SetWindowRect(webview_,
-                            gfx::Rect(ir.x(), ir.y(), ir.width(), ir.height()));
+    delegate->setWindowRect(
+        webkit_glue::IntRectToWebRect(WebCore::IntRect(r)));
   }
 }
 
 WebCore::FloatRect ChromeClientImpl::windowRect() {
   WebRect rect;
   if (webview_->delegate()) {
-    webview_->delegate()->GetRootWindowRect(webview_, &rect);
+    rect = webview_->delegate()->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(static_cast<float>(rect.x),
-                            static_cast<float>(rect.y),
-                            static_cast<float>(rect.width),
-                            static_cast<float>(rect.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->Focus(webview_);
+    delegate->didFocus();
 
   // If accessibility is enabled, we should notify assistive technology that the
   // active AccessibilityObject changed.
   WebCore::Document* doc = webview_->GetFocusedWebCoreFrame()->document();
 
   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);
     }
   }
 }
 
 void ChromeClientImpl::unfocus() {
   WebViewDelegate* delegate = webview_->delegate();
   if (delegate)
-    delegate->Blur(webview_);
+    delegate->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) {
   WebViewDelegate* delegate = webview_->delegate();
@@ skipping 54 matching lines @@
     // new window be opened as a toplevel window.
     //
     bool as_popup =
         !toolbars_visible_ ||
         !statusbar_visible_ ||
         !scrollbars_visible_ ||
         !menubar_visible_ ||
         !resizable_ ||
         !delegate->WasOpenedByUserGesture();
 
-    WindowOpenDisposition disposition = NEW_FOREGROUND_TAB;
+    WebNavigationPolicy policy = WebKit::WebNavigationPolicyNewForegroundTab;
     if (as_popup)
-      disposition = NEW_POPUP;
+      policy = WebKit::WebNavigationPolicyNewPopup;
     if (CurrentEventShouldCauseBackgroundTab(WebViewImpl::current_input_event()))
-      disposition = NEW_BACKGROUND_TAB;
+      policy = WebKit::WebNavigationPolicyNewBackgroundTab;
 
-    delegate->Show(webview_, disposition);
+    delegate->show(policy);
   }
 }
 
 bool ChromeClientImpl::canRunModal() {
   return webview_->delegate() != NULL;
 }
 
 void ChromeClientImpl::runModal() {
   WebViewDelegate* delegate = webview_->delegate();
   if (delegate)
-    delegate->RunModal(webview_);
+    delegate->runModal();
 }
 
 void ChromeClientImpl::setToolbarsVisible(bool value) {
   toolbars_visible_ = value;
 }
 
 bool ChromeClientImpl::toolbarsVisible() {
   return toolbars_visible_;
 }
 
@@ skipping 62 matching lines @@
 
 void ChromeClientImpl::closeWindowSoon() {
   // Make sure this Page can no longer be found by JS.
   webview_->page()->setGroupName(WebCore::String());
 
   // Make sure that all loading is stopped.  Ensures that JS stops executing!
   webview_->StopLoading();
 
   WebViewDelegate* delegate = webview_->delegate();
   if (delegate)
-    delegate->CloseWidgetSoon(webview_);
+    delegate->closeWidgetSoon();
 }
 
 // Although a WebCore::Frame is passed in, we don't actually use it, since we
 // already know our own webview_.
 void ChromeClientImpl::runJavaScriptAlert(WebCore::Frame* frame,
                                           const WebCore::String& message) {
   // Pass the request on to the WebView delegate, for more control.
   WebViewDelegate* delegate = webview_->delegate();
   if (delegate) {
 #if USE(V8)
@@ skipping 56 matching lines @@
   // TODO(pamg): Consider controlling this with a user preference, when we have
   // a preference system in place.
   // For now Chrome will allow link to take focus if we're not running layout
   // tests.
   return !WebKit::layoutTestMode();
 }
 
 WebCore::IntRect ChromeClientImpl::windowResizerRect() const {
   WebCore::IntRect result;
   if (webview_->delegate()) {
-    WebRect resizer_rect;
-    webview_->delegate()->GetRootWindowResizerRect(webview_, &resizer_rect);
-    result = webkit_glue::WebRectToIntRect(resizer_rect);
+    result = webkit_glue::WebRectToIntRect(
+        webview_->delegate()->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(webview_,
-                                webkit_glue::IntRectToWebRect(paint_rect));
+    delegate->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) {
     int dx = scroll_delta.width();
     int dy = scroll_delta.height();
-    delegate->DidScrollRect(webview_, dx, dy,
-                            webkit_glue::IntRectToWebRect(clip_rect));
+    delegate->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->GetWindowRect(webview_, &window_rect);
+    WebRect window_rect = delegate->windowRect();
     screen_rect.move(window_rect.x, window_rect.y);
   }
 
   return screen_rect;
 }
 
 PlatformWidget ChromeClientImpl::platformWindow() const {
   return NULL;
 }
 
@@ skipping 68 matching lines @@
 
   WebWidget* webwidget;
   if (handle_externally) {
     WebPopupMenuInfo popup_info;
     GetPopupMenuInfo(popup_container, &popup_info);
     webwidget = delegate->CreatePopupWidgetWithInfo(webview_, popup_info);
   } else {
     webwidget = delegate->CreatePopupWidget(webview_, activatable);
   }
 
-  static_cast<WebWidgetImpl*>(webwidget)->Init(
+  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->SetCursor(webview_, cursor);
+    delegate->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 28 matching lines @@
         break;
       default:
         NOTREACHED();
     }
   }
 
   info->itemHeight = popup_container->menuItemHeight();
   info->selectedIndex = popup_container->selectedIndex();
   info->items.swap(output_items);
 }