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

webkit/tools/test_shell/mac/test_webview_delegate.mm

 // Copyright (c) 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 "webkit/tools/test_shell/test_webview_delegate.h"
 
 #import <Cocoa/Cocoa.h>
 #include "base/string_util.h"
 #include "base/sys_string_conversions.h"
 #include "webkit/api/public/WebCursorInfo.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webview.h"
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 #include "webkit/glue/webmenurunner_mac.h"
 #include "webkit/tools/test_shell/test_shell.h"
 
 using WebKit::WebCursorInfo;
+using WebKit::WebNavigationPolicy;
 using WebKit::WebPopupMenuInfo;
 using WebKit::WebRect;
+using WebKit::WebWidget;
 
 // WebViewDelegate -----------------------------------------------------------
 
 TestWebViewDelegate::~TestWebViewDelegate() {
 }
 
 WebWidget* TestWebViewDelegate::CreatePopupWidgetWithInfo(
     WebView* webview,
     const WebPopupMenuInfo& info) {
   WebWidget* webwidget = shell_->CreatePopupWidget(webview);
   popup_menu_info_.reset(new WebPopupMenuInfo(info));
   return webwidget;
 }
 
 WebPluginDelegate* TestWebViewDelegate::CreatePluginDelegate(
     WebView* webview,
     const GURL& url,
     const std::string& mime_type,
     const std::string& clsid,
     std::string* actual_mime_type) {
-  WebWidgetHost *host = GetHostForWidget(webview);
+  WebWidgetHost *host = GetWidgetHost();
   if (!host)
     return NULL;
   gfx::NativeView view = host->view_handle();
 
   bool allow_wildcard = true;
   WebPluginInfo info;
   if (!NPAPI::PluginList::Singleton()->GetPluginInfo(url, mime_type, clsid,
                                                      allow_wildcard, &info,
                                                      actual_mime_type))
     return NULL;
 
   if (actual_mime_type && !actual_mime_type->empty())
     return WebPluginDelegateImpl::Create(info.path, *actual_mime_type, view);
   else
     return WebPluginDelegateImpl::Create(info.path, mime_type, view);
 }
 
+void TestWebViewDelegate::DidMovePlugin(const WebPluginGeometry& move) {
+  // TODO(port): add me once plugins work.
+}
+
 void TestWebViewDelegate::ShowJavaScriptAlert(const std::wstring& message) {
   NSString *text =
       [NSString stringWithUTF8String:WideToUTF8(message).c_str()];
   NSAlert *alert = [NSAlert alertWithMessageText:@"JavaScript Alert"
                                    defaultButton:@"OK"
                                  alternateButton:nil
                                      otherButton:nil
                        informativeTextWithFormat:text];
   [alert runModal];
 }
 
 
 // WebWidgetDelegate ---------------------------------------------------------
 
-void TestWebViewDelegate::Show(WebWidget* webwidget,
-                               WindowOpenDisposition disposition) {
+void TestWebViewDelegate::show(WebNavigationPolicy policy) {
   if (!popup_menu_info_.get())
     return;
-  if (webwidget != shell_->popup())
+  if (this != shell_->popup_delegate())
     return;
   // Display a HTML select menu.
 
   std::vector<WebMenuItem> items;
   for (size_t i = 0; i < popup_menu_info_->items.size(); ++i)
     items.push_back(popup_menu_info_->items[i]);
 
   int item_height = popup_menu_info_->itemHeight;
   int selected_index = popup_menu_info_->selectedIndex;
   popup_menu_info_.reset();  // No longer needed.
@@ skipping 30 matching lines @@
     // Construct a mouse up event to simulate the selection of an appropriate
     // menu item.
     popup->MouseEvent(event);
   } else {
     // Fake an ESC key event (keyCode = 0x1B, from webinputevent_mac.mm) and
     // forward that to WebKit.
     popup->KeyEvent(event);
   }
 }
 
-void TestWebViewDelegate::CloseWidgetSoon(WebWidget* webwidget) {
-  if (webwidget == shell_->webView()) {
+void TestWebViewDelegate::closeWidgetSoon() {
+  if (this == shell_->delegate()) {
     NSWindow *win = shell_->mainWnd();
     // Tell Cocoa to close the window, which will let the window's delegate
     // handle getting rid of the shell. |shell_| will still be alive for a short
     // period of time after this call returns (cleanup is done after going back
     // to the event loop), so we should make sure we don't leave it dangling.
     [win performClose:nil];
     shell_ = NULL;
-  } else if (webwidget == shell_->popup()) {
+  } else if (this == shell_->popup_delegate()) {
     shell_->ClosePopup();
   }
 }
 
-void TestWebViewDelegate::SetCursor(WebWidget* webwidget,
-                                    const WebCursorInfo& cursor_info) {
+void TestWebViewDelegate::didChangeCursor(const WebCursorInfo& cursor_info) {
   NSCursor* ns_cursor = WebCursor(cursor_info).GetCursor();
   [ns_cursor set];
 }
 
-void TestWebViewDelegate::GetWindowRect(WebWidget* webwidget,
-                                        WebRect* out_rect) {
-  DCHECK(out_rect);
-  if (WebWidgetHost* host = GetHostForWidget(webwidget)) {
+WebRect TestWebViewDelegate::windowRect() {
+  if (WebWidgetHost* host = GetWidgetHost()) {
     NSView *view = host->view_handle();
     NSRect rect = [view frame];
-    *out_rect = gfx::Rect(NSRectToCGRect(rect));
+    return gfx::Rect(NSRectToCGRect(rect));
   }
+  return WebRect();
 }
 
-void TestWebViewDelegate::SetWindowRect(WebWidget* webwidget,
-                                        const WebRect& rect) {
+void TestWebViewDelegate::setWindowRect(const WebRect& rect) {
   // TODO: Mac window movement
-  if (webwidget == shell_->webView()) {
+  if (this == shell_->delegate()) {
     // ignored
-  } else if (webwidget == shell_->popup()) {
+  } else if (this == shell_->popup_delegate()) {
     popup_bounds_ = rect;  // The initial position of the popup.
   }
 }
 
-void TestWebViewDelegate::GetRootWindowRect(WebWidget* webwidget,
-                                            WebRect* out_rect) {
-  if (WebWidgetHost* host = GetHostForWidget(webwidget)) {
+WebRect TestWebViewDelegate::rootWindowRect() {
+  if (WebWidgetHost* host = GetWidgetHost()) {
     NSView *view = host->view_handle();
     NSRect rect = [[[view window] contentView] frame];
-    *out_rect = gfx::Rect(NSRectToCGRect(rect));
+    return gfx::Rect(NSRectToCGRect(rect));
   }
+  return WebRect();
 }
 
 @interface NSWindow(OSInternals)
 - (NSRect)_growBoxRect;
 @end
 
-void TestWebViewDelegate::GetRootWindowResizerRect(WebWidget* webwidget,
-                                                   WebRect* out_rect) {
+WebRect TestWebViewDelegate::windowResizerRect() {
   NSRect resize_rect = NSMakeRect(0, 0, 0, 0);
-  WebWidgetHost* host = GetHostForWidget(webwidget);
+  WebWidgetHost* host = GetWidgetHost();
   // To match the WebKit screen shots, we need the resize area to overlap
   // the scroll arrows, so in layout test mode, we don't return a real rect.
   if (!(shell_->layout_test_mode()) && host) {
     NSView *view = host->view_handle();
     NSWindow* window = [view window];
     resize_rect = [window _growBoxRect];
     // The scrollbar assumes that the resizer goes all the way down to the
     // bottom corner, so we ignore any y offset to the rect itself and use the
     // entire bottom corner.
     resize_rect.origin.y = 0;
     // Convert to view coordinates from window coordinates.
     resize_rect = [view convertRect:resize_rect fromView:nil];
     // Flip the rect in view coordinates
     resize_rect.origin.y =
         [view frame].size.height - resize_rect.origin.y -
         resize_rect.size.height;
   }
-  *out_rect = gfx::Rect(NSRectToCGRect(resize_rect));
+  return gfx::Rect(NSRectToCGRect(resize_rect));
 }
 
-void TestWebViewDelegate::DidMove(WebWidget* webwidget,
-                                  const WebPluginGeometry& move) {
-  // TODO(port): add me once plugins work.
-}
-
-void TestWebViewDelegate::RunModal(WebWidget* webwidget) {
+void TestWebViewDelegate::runModal() {
   NOTIMPLEMENTED();
 }
 
 void TestWebViewDelegate::UpdateSelectionClipboard(bool is_empty_selection) {
   // No selection clipboard on mac, do nothing.
 }
 
 // Private methods -----------------------------------------------------------
 
 void TestWebViewDelegate::SetPageTitle(const std::wstring& title) {
   [[shell_->webViewHost()->view_handle() window]
       setTitle:[NSString stringWithUTF8String:WideToUTF8(title).c_str()]];
 }
 
 void TestWebViewDelegate::SetAddressBarURL(const GURL& url) {
   const char* frameURL = url.spec().c_str();
   NSString *address = [NSString stringWithUTF8String:frameURL];
   [shell_->editWnd() setStringValue:address];
 }