Use cocoa controls for HTML select popups in test_shell

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 "Cursor.h"
 #include "FloatRect.h"
 #include "FileChooser.h"
 #include "FrameLoadRequest.h"
 #include "FrameView.h"
 #include "HitTestResult.h"
 #include "IntRect.h"
 #include "Page.h"
+#include "PopupMenuChromium.h"
 #include "ScriptController.h"
 #include "WindowFeatures.h"
 #if USE(V8)
 #include "v8_proxy.h"
 #endif
 MSVC_POP_WARNING();
 
 #undef LOG
 
 #include "webkit/glue/chrome_client_impl.h"
@@ skipping 51 matching lines @@
 }
 
 ChromeClientImpl::~ChromeClientImpl() {
 }
 
 void ChromeClientImpl::chromeDestroyed() {
   delete this;
 }
 
 void ChromeClientImpl::setWindowRect(const WebCore::FloatRect& r) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     WebCore::IntRect ir(r);
-    d->SetWindowRect(webview_,
-                     gfx::Rect(ir.x(), ir.y(), ir.width(), ir.height()));
+    delegate->SetWindowRect(webview_,
+                            gfx::Rect(ir.x(), ir.y(), ir.width(), ir.height()));
   }
 }
 
 WebCore::FloatRect ChromeClientImpl::windowRect() {
   if (webview_->delegate()) {
     gfx::Rect rect;
     webview_->delegate()->GetRootWindowRect(webview_, &rect);
     return WebCore::FloatRect(
         static_cast<float>(rect.x()),
         static_cast<float>(rect.y()),
@@ skipping 25 matching lines @@
   // 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* d = webview_->delegate();
-  if (d)
-    d->Focus(webview_);
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->Focus(webview_);
 }
 
 void ChromeClientImpl::unfocus() {
-  WebViewDelegate* d = webview_->delegate();
-  if (d)
-    d->Blur(webview_);
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->Blur(webview_);
 }
 
 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* d = webview_->delegate();
-  if (d) {
-    d->TakeFocus(webview_,
-                 direction == WebCore::FocusDirectionBackward);
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
+    delegate->TakeFocus(webview_,
+                        direction == WebCore::FocusDirectionBackward);
   }
 }
 
 WebCore::Page* ChromeClientImpl::createWindow(
     WebCore::Frame* frame, const WebCore::FrameLoadRequest& r,
     const WebCore::WindowFeatures& features) {
-  WebViewDelegate* d = webview_->delegate();
-  if (!d)
+  WebViewDelegate* delegate = webview_->delegate();
+  if (!delegate)
     return NULL;
 
   bool userGesture = frame->script()->processingUserGesture();
   WebViewImpl* new_view = static_cast<WebViewImpl*>(
-      d->CreateWebView(webview_, userGesture));
+      delegate->CreateWebView(webview_, userGesture));
   if (!new_view)
     return NULL;
 
   // 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()) {
     WebRequestImpl request(r);
     new_view->main_frame()->LoadRequest(&request);
   }
 
   WebViewImpl* new_view_impl = static_cast<WebViewImpl*>(new_view);
   return new_view_impl->page();
 }
 
 static inline bool CurrentEventShouldCauseBackgroundTab(
     const WebInputEvent* input_event) {
   if (!input_event)
     return false;
 
   if (input_event->type != WebInputEvent::MOUSE_UP)
     return false;
 
   const WebMouseEvent* mouse_event = static_cast<const WebMouseEvent*>(input_event);
   return (mouse_event->button == WebMouseEvent::BUTTON_MIDDLE);
 }
 
 void ChromeClientImpl::show() {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     // 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 as_popup =
         !toolbars_visible_ ||
         !statusbar_visible_ ||
         !scrollbars_visible_ ||
         !menubar_visible_ ||
         !resizable_ ||
-        !d->WasOpenedByUserGesture(webview_);
+        !delegate->WasOpenedByUserGesture(webview_);
 
     WindowOpenDisposition disposition = NEW_FOREGROUND_TAB;
     if (as_popup)
       disposition = NEW_POPUP;
     if (CurrentEventShouldCauseBackgroundTab(WebViewImpl::current_input_event()))
       disposition = NEW_BACKGROUND_TAB;
 
-    d->Show(webview_, disposition);
+    delegate->Show(webview_, disposition);
   }
 }
 
 bool ChromeClientImpl::canRunModal() {
   return webview_->delegate() != NULL;
 }
 
 void ChromeClientImpl::runModal() {
-  WebViewDelegate* d = webview_->delegate();
-  if (d)
-    d->RunModal(webview_);
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->RunModal(webview_);
 }
 
 void ChromeClientImpl::setToolbarsVisible(bool value) {
   toolbars_visible_ = value;
 }
 
 bool ChromeClientImpl::toolbarsVisible() {
   return toolbars_visible_;
 }
 
@@ skipping 25 matching lines @@
   return menubar_visible_;
 }
 
 void ChromeClientImpl::setResizable(bool value) {
   resizable_ = value;
 }
 
 void ChromeClientImpl::addMessageToConsole(const WebCore::String& message,
                                            unsigned int line_no,
                                            const WebCore::String& source_id) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     std::wstring wstr_message = webkit_glue::StringToStdWString(message);
     std::wstring wstr_source_id = webkit_glue::StringToStdWString(source_id);
-    d->AddMessageToConsole(webview_, wstr_message, line_no, wstr_source_id);
+    delegate->AddMessageToConsole(webview_, wstr_message,
+                                  line_no, wstr_source_id);
   }
 }
 
 bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel() {
   return webview_->delegate() != NULL;
 }
 
 bool ChromeClientImpl::runBeforeUnloadConfirmPanel(
     const WebCore::String& message,
     WebCore::Frame* frame) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     std::wstring wstr = webkit_glue::StringToStdWString(message);
-    return d->RunBeforeUnloadConfirm(WebFrameImpl::FromFrame(frame), wstr);
+    return delegate->RunBeforeUnloadConfirm(WebFrameImpl::FromFrame(frame),
+                                            wstr);
   }
   return false;
 }
 
 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* d = webview_->delegate();
-  if (d)
-    d->CloseWidgetSoon(webview_);
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->CloseWidgetSoon(webview_);
 }
 
 // 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* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
 #if USE(V8)
     // Before showing the JavaScript dialog, we give the proxy implementation
     // a chance to process any pending console messages.
     WebCore::V8Proxy::ProcessConsoleMessages();
 #endif
 
     std::wstring wstr = webkit_glue::StringToStdWString(message);
-    d->RunJavaScriptAlert(WebFrameImpl::FromFrame(frame), wstr);
+    delegate->RunJavaScriptAlert(WebFrameImpl::FromFrame(frame), wstr);
   }
 }
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptConfirm(WebCore::Frame* frame,
                                             const WebCore::String& message) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     std::wstring wstr = webkit_glue::StringToStdWString(message);
-    return d->RunJavaScriptConfirm(WebFrameImpl::FromFrame(frame), wstr);
+    return delegate->RunJavaScriptConfirm(WebFrameImpl::FromFrame(frame), wstr);
   }
   return false;
 }
 
 // See comments for runJavaScriptAlert().
 bool ChromeClientImpl::runJavaScriptPrompt(WebCore::Frame* frame,
                                            const WebCore::String& message,
                                            const WebCore::String& defaultValue,
                                            WebCore::String& result) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     std::wstring wstr_message = webkit_glue::StringToStdWString(message);
     std::wstring wstr_default = webkit_glue::StringToStdWString(defaultValue);
     std::wstring wstr_result;
-    bool ok = d->RunJavaScriptPrompt(WebFrameImpl::FromFrame(frame),
-                                     wstr_message,
-                                     wstr_default,
-                                     &wstr_result);
+    bool ok = delegate->RunJavaScriptPrompt(WebFrameImpl::FromFrame(frame),
+                                            wstr_message,
+                                            wstr_default,
+                                            &wstr_result);
     if (ok)
       result = webkit_glue::StdWStringToString(wstr_result);
     return ok;
   }
   return false;
 }
 
 void ChromeClientImpl::setStatusbarText(const WebCore::String& message) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     std::wstring wstr = webkit_glue::StringToStdWString(message);
-    d->SetStatusbarText(webview_, wstr);
+    delegate->SetStatusbarText(webview_, wstr);
   }
 }
 
 bool ChromeClientImpl::shouldInterruptJavaScript() {
   // TODO(mbelshe): implement me
   return false;
 }
 
 bool ChromeClientImpl::tabsToLinks() const {
   // TODO(pamg): Consider controlling this with a user preference, when we have
@@ skipping 15 matching lines @@
   }
   return rv;
 }
 
 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* d = webview_->delegate();
-  if (d)
-    d->DidInvalidateRect(webview_, webkit_glue::FromIntRect(paint_rect));
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->DidInvalidateRect(webview_, webkit_glue::FromIntRect(paint_rect));
 }
 
 void ChromeClientImpl::scroll(
     const WebCore::IntSize& scroll_delta, const WebCore::IntRect& scroll_rect,
     const WebCore::IntRect& clip_rect) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     int dx = scroll_delta.width();
     int dy = scroll_delta.height();
-    d->DidScrollRect(webview_, dx, dy, webkit_glue::FromIntRect(clip_rect));
+    delegate->DidScrollRect(webview_, dx, dy,
+                            webkit_glue::FromIntRect(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* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     gfx::Rect window_rect;
-    d->GetWindowRect(webview_, &window_rect);
+    delegate->GetWindowRect(webview_, &window_rect);
     screen_rect.move(window_rect.x(), window_rect.y());
   }
 
   return screen_rect;
 }
 
 PlatformWidget ChromeClientImpl::platformWindow() const {
-  WebViewDelegate* d = webview_->delegate();
-  return d ? d->GetContainingView(webview_) : NULL;
+  WebViewDelegate* delegate = webview_->delegate();
+  return delegate ? delegate->GetContainingView(webview_) : NULL;
 }
 
 void ChromeClientImpl::mouseDidMoveOverElement(
     const WebCore::HitTestResult& result, unsigned modifierFlags) {
   // Find out if the mouse is over a link, and if so, let our UI know... somehow
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     if (result.isLiveLink() && !result.absoluteLinkURL().string().isEmpty()) {
-      d->UpdateTargetURL(webview_, webkit_glue::KURLToGURL(result.absoluteLinkURL()));
+      delegate->UpdateTargetURL(
+          webview_, webkit_glue::KURLToGURL(result.absoluteLinkURL()));
     } else {
-      d->UpdateTargetURL(webview_, GURL());
+      delegate->UpdateTargetURL(webview_, GURL());
     }
   }
 }
 
 void ChromeClientImpl::setToolTip(const WebCore::String& tooltip_text) {
   if (webview_->delegate()) {
     std::wstring tooltip_text_as_wstring =
       webkit_glue::StringToStdWString(tooltip_text);
     webview_->delegate()->SetTooltipText(webview_, tooltip_text_as_wstring);
   }
 }
 
 void ChromeClientImpl::print(WebCore::Frame* frame) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
-    d->ScriptedPrint(WebFrameImpl::FromFrame(frame));
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
+    delegate->ScriptedPrint(WebFrameImpl::FromFrame(frame));
   }
 }
 
 void ChromeClientImpl::exceededDatabaseQuota(WebCore::Frame* frame,
     const WebCore::String& databaseName) {
   // TODO(tc): If we enable the storage API, we need to implement this function.
 }
 
 void ChromeClientImpl::runOpenPanel(WebCore::Frame* frame,
   PassRefPtr<WebCore::FileChooser> fileChooser) {
   WebViewDelegate* delegate = webview_->delegate();
   if (!delegate)
     return;
 
   bool multiple_files = fileChooser->allowsMultipleFiles();
 
   std::wstring suggestion;
   if (fileChooser->filenames().size() > 0)
     suggestion = webkit_glue::StringToStdWString(fileChooser->filenames()[0]);
 
   WebFileChooserCallbackImpl* chooser = new WebFileChooserCallbackImpl(fileChooser);
   delegate->RunFileChooser(multiple_files, std::wstring(), suggestion,
                            std::wstring(), chooser);
 }
 
 void ChromeClientImpl::popupOpened(WebCore::FramelessScrollView* popup_view,
                                    const WebCore::IntRect& bounds,
                                    bool activatable) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d) {
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate) {
     WebWidgetImpl* webwidget =
-        static_cast<WebWidgetImpl*>(d->CreatePopupWidget(webview_,
-                                                         activatable));
+        static_cast<WebWidgetImpl*>(delegate->CreatePopupWidget(webview_,
+                                                                activatable));
     webwidget->Init(popup_view, webkit_glue::FromIntRect(bounds));
   }
 }
 
+void ChromeClientImpl::popupOpenedWithItems(
+    WebCore::FramelessScrollView* popup_view,
+    const WebCore::IntRect& bounds,
+    bool activatable,
+    int item_height,
+    int selected_index,
+    const WTF::Vector<WebCore::PopupListData*>& items) {
+  /*
+  Uncomment this section once the changes to
+  WebKit/WebCore/platform/chromium/PopupMenuChromium* have landed in our tree.
+
+  WebViewDelegate* delegate = webview_->delegate();
+  if (!delegate)
+    return;
+
+  WebWidgetImpl* webwidget =
+      static_cast<WebWidgetImpl*>(delegate->CreatePopupWidget(webview_,
+                                                              activatable));
+  // Convert WebKit types for Chromium.
+  std::vector<MenuItem> popup_items;
+  for (int i = 0; i < items.size(); ++i) {
+    MenuItem menu_item;
+    menu_item.label = webkit_glue::StringToString16(items[i]->label);
+    menu_item.enabled = items[i]->enabled;
+    switch (items[i]->type) {
+      case WebCore::PopupListData::TypeOption:
+        menu_item.type = MenuItem::OPTION;
+        break;
+      case WebCore::PopupListData::TypeGroup:
+        menu_item.type = MenuItem::GROUP;
+        break;
+      case WebCore::PopupListData::TypeSeparator:
+        menu_item.type = MenuItem::SEPARATOR;
+        break;
+      default:
+        NOTIMPLEMENTED();
+    }
+    popup_items.push_back(menu_item);
+  }
+
+  webwidget->InitWithItems(popup_view,
+                           webkit_glue::FromIntRect(bounds),
+                           item_height,
+                           selected_index,
+                           popup_items);
+  */
+}
+
 void ChromeClientImpl::SetCursor(const WebCursor& cursor) {
   if (ignore_next_set_cursor_) {
     ignore_next_set_cursor_ = false;
     return;
   }
 
-  WebViewDelegate* d = webview_->delegate();
-  if (d)
-    d->SetCursor(webview_, cursor);
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->SetCursor(webview_, cursor);
 }
 
 void ChromeClientImpl::SetCursorForPlugin(const WebCursor& 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;
 }
 
 void ChromeClientImpl::enableSuddenTermination() {
-  WebViewDelegate* d = webview_->delegate();
-  if (d)
-    d->EnableSuddenTermination();
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->EnableSuddenTermination();
 }
 
 void ChromeClientImpl::disableSuddenTermination() {
-  WebViewDelegate* d = webview_->delegate();
-  if (d)
-    d->DisableSuddenTermination();
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->DisableSuddenTermination();
 }
 
 void ChromeClientImpl::formStateDidChange(const WebCore::Node*) {
-  WebViewDelegate* d = webview_->delegate();
-  if (d)
-    d->OnNavStateChanged(webview_);
+  WebViewDelegate* delegate = webview_->delegate();
+  if (delegate)
+    delegate->OnNavStateChanged(webview_);
 }