First stage of implementing HTML select popup menus for

the Mac test_shell. Once the changes to
WebKit/WebCore/platform/chromium/PopupMenuChromium* have
been upstreamed (then landed in our tree), we can enable
them in test_shell.

The WebKit part is contained in this bug:
https://bugs.webkit.org/show_bug.cgi?id=24692

BUG=5095 (http://crbug.com/5095)

Review URL: http://codereview.chromium.org/48149

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@12382 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 200 insertions, 84 deletions

diff --git a/webkit/glue/chrome_client_impl.cc b/webkit/glue/chrome_client_impl.cc
index 972a643..6b574d5 100644
--- a/webkit/glue/chrome_client_impl.cc
+++ b/webkit/glue/chrome_client_impl.cc
@@ -15,6 +15,7 @@ MSVC_PUSH_WARNING_LEVEL(0);
 #include "HitTestResult.h"
 #include "IntRect.h"
 #include "Page.h"
+#include "PopupMenuChromium.h"
 #include "ScriptController.h"
 #include "WindowFeatures.h"
 #if USE(V8)
@@ -86,11 +87,11 @@ void ChromeClientImpl::chromeDestroyed() {
 }
 
 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()));
   }
 }
 
@@ -136,15 +137,15 @@ float ChromeClientImpl::scaleFactor() {
 }
 
 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) {
@@ -154,23 +155,23 @@ bool ChromeClientImpl::canTakeFocus(WebCore::FocusDirection) {
 }
 
 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;
 
@@ -198,8 +199,8 @@ static inline bool CurrentEventShouldCauseBackgroundTab(
 }
 
 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.
@@ -210,7 +211,7 @@ void ChromeClientImpl::show() {
         !scrollbars_visible_ ||
         !menubar_visible_ ||
         !resizable_ ||
-        !d->WasOpenedByUserGesture(webview_);
+        !delegate->WasOpenedByUserGesture(webview_);
 
     WindowOpenDisposition disposition = NEW_FOREGROUND_TAB;
     if (as_popup)
@@ -218,7 +219,7 @@ void ChromeClientImpl::show() {
     if (CurrentEventShouldCauseBackgroundTab(WebViewImpl::current_input_event()))
       disposition = NEW_BACKGROUND_TAB;
 
-    d->Show(webview_, disposition);
+    delegate->Show(webview_, disposition);
   }
 }
 
@@ -227,9 +228,9 @@ bool ChromeClientImpl::canRunModal() {
 }
 
 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) {
@@ -275,11 +276,12 @@ void ChromeClientImpl::setResizable(bool 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);
   }
 }
 
@@ -290,10 +292,11 @@ bool ChromeClientImpl::canRunBeforeUnloadConfirmPanel() {
 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;
 }
@@ -305,9 +308,9 @@ void ChromeClientImpl::closeWindowSoon() {
   // 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
@@ -315,8 +318,8 @@ void ChromeClientImpl::closeWindowSoon() {
 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.
@@ -324,17 +327,17 @@ void ChromeClientImpl::runJavaScriptAlert(WebCore::Frame* frame,
 #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;
 }
@@ -344,15 +347,15 @@ 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;
@@ -361,10 +364,10 @@ bool ChromeClientImpl::runJavaScriptPrompt(WebCore::Frame* frame,
 }
 
 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);
   }
 }
 
@@ -400,19 +403,20 @@ void ChromeClientImpl::repaint(
   // 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));
   }
 }
 
@@ -426,10 +430,10 @@ 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());
   }
 
@@ -437,19 +441,20 @@ WebCore::IntRect ChromeClientImpl::windowToScreen(
 }
 
 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());
     }
   }
 }
@@ -463,9 +468,9 @@ void ChromeClientImpl::setToolTip(const WebCore::String& tooltip_text) {
 }
 
 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));
   }
 }
 
@@ -494,24 +499,72 @@ void ChromeClientImpl::runOpenPanel(WebCore::Frame* frame,
 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) {
@@ -523,19 +576,19 @@ void ChromeClientImpl::SetCursorForPlugin(const WebCursor& cursor) {
 }
 
 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_);
 }
diff --git a/webkit/glue/chrome_client_impl.h b/webkit/glue/chrome_client_impl.h
index 2c6fc22..bf515d2 100644
--- a/webkit/glue/chrome_client_impl.h
+++ b/webkit/glue/chrome_client_impl.h
@@ -15,6 +15,7 @@ class WebCursor;
 class WebViewImpl;
 
 namespace WebCore {
+struct PopupListData;
 class SecurityOrigin;
 struct WindowFeatures;
 }
@@ -118,6 +119,12 @@ class ChromeClientImpl : public WebCore::ChromeClientChromium {
   virtual void popupOpened(WebCore::FramelessScrollView* popup_view,
                            const WebCore::IntRect& bounds,
                            bool activatable);
+  void popupOpenedWithItems(WebCore::FramelessScrollView* popupView,
+                            const WebCore::IntRect& bounds,
+                            bool activatable,
+                            int item_height,
+                            int selected_index,
+                            const WTF::Vector<WebCore::PopupListData*>& items);
 
   void SetCursor(const WebCursor& cursor);
   void SetCursorForPlugin(const WebCursor& cursor);
diff --git a/webkit/glue/webwidget_delegate.h b/webkit/glue/webwidget_delegate.h
index 010a7d0..05ed760 100644
--- a/webkit/glue/webwidget_delegate.h
+++ b/webkit/glue/webwidget_delegate.h
@@ -5,7 +5,11 @@
 #ifndef WEBKIT_GLUE_WEBWIDGET_DELEGATE_H__
 #define WEBKIT_GLUE_WEBWIDGET_DELEGATE_H__
 
+#include <string>
+#include <vector>
+
 #include "base/gfx/native_widget_types.h"
+#include "base/string16.h"
 #include "webkit/glue/window_open_disposition.h"
 
 namespace gfx {
@@ -17,6 +21,22 @@ class WebWidget;
 class WebCursor;
 struct WebPluginGeometry;
 
+struct MenuItem {
+  // Container for information about entries in an HTML select popup menu.
+  // Types must be kept in sync with PopupListBox::ListItemType in
+  // WebCore/platform/chromium/PopupMenuChromium.h. This won't change often
+  // (if ever).
+  enum Type {
+    OPTION = 0,
+    GROUP,
+    SEPARATOR
+  };
+
+  string16 label;
+  Type type;
+  bool enabled;
+};
+
 class WebWidgetDelegate {
  public:
   // Returns the view in which the WebWidget is embedded.
@@ -36,6 +56,22 @@ class WebWidgetDelegate {
   // window should be displayed, but generally only means something for WebViews.
   virtual void Show(WebWidget* webwidget, WindowOpenDisposition disposition) = 0;
 
+  // Used for displaying HTML select elements as popup menus on Mac OS X (other
+  // platforms will use Show() above). |bounds| represents the positioning on
+  // the screen (in WebKit coordinates, origin at the top left corner) of the
+  // button that will display the menu. It will be used, along with
+  // |item_height| (which refers to the size of each entry in the menu), to
+  // position the menu on the screen. |selected_index| indicates the menu item
+  // that should be drawn as selected when the menu initially is displayed.
+  // |items| contains information about each of the entries in the popup menu,
+  // such as the type (separator, option, group), the text representation and
+  // the item's enabled status.
+  virtual void ShowWithItems(WebWidget* webwidget,
+                             const gfx::Rect& bounds,
+                             int item_height,
+                             int selected_index,
+                             const std::vector<MenuItem>& items) = 0;
+
   // This method is called to instruct the window containing the WebWidget to
   // close.  Note: This method should just be the trigger that causes the
   // WebWidget to eventually close.  It should not actually be destroyed until
@@ -91,7 +127,7 @@ class WebWidgetDelegate {
   virtual ~WebWidgetDelegate() { }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(WebWidgetDelegate);
+  DISALLOW_COPY_AND_ASSIGN(WebWidgetDelegate);
 };
 
 #endif  // #ifndef WEBKIT_GLUE_WEBWIDGET_DELEGATE_H__
diff --git a/webkit/glue/webwidget_impl.cc b/webkit/glue/webwidget_impl.cc
index b745a66..5cf6bbe 100644
--- a/webkit/glue/webwidget_impl.cc
+++ b/webkit/glue/webwidget_impl.cc
@@ -62,6 +62,20 @@ void WebWidgetImpl::Init(WebCore::FramelessScrollView* widget,
   }
 }
 
+void WebWidgetImpl::InitWithItems(WebCore::FramelessScrollView* widget,
+                                  const gfx::Rect& bounds,
+                                  int item_height,
+                                  int selected_index,
+                                  const std::vector<MenuItem>& items) {
+  widget_ = widget;
+  widget_->setClient(this);
+
+  if (delegate_) {
+    delegate_->SetWindowRect(this, bounds);
+    delegate_->ShowWithItems(this, bounds, item_height, selected_index, items);
+  }
+}
+
 void WebWidgetImpl::MouseMove(const WebMouseEvent& event) {
   // don't send mouse move messages if the mouse hasn't moved.
   if (event.x != last_mouse_position_.x() ||
diff --git a/webkit/glue/webwidget_impl.h b/webkit/glue/webwidget_impl.h
index efb1b65..e6decf4 100644
--- a/webkit/glue/webwidget_impl.h
+++ b/webkit/glue/webwidget_impl.h
@@ -25,6 +25,7 @@ namespace WebCore {
   class Widget;
 }
 
+struct MenuItem;
 class WebKeyboardEvent;
 class WebMouseEvent;
 class WebMouseWheelEvent;
@@ -53,6 +54,11 @@ class WebWidgetImpl : public WebWidget,
 
   // WebWidgetImpl
   void Init(WebCore::FramelessScrollView* widget, const gfx::Rect& bounds);
+  void InitWithItems(WebCore::FramelessScrollView* widget,
+                     const gfx::Rect& bounds,
+                     int item_height,
+                     int selected_index,
+                     const std::vector<MenuItem>& items);
 
   const gfx::Size& size() const { return size_; }
 
@@ -110,7 +116,7 @@ class WebWidgetImpl : public WebWidget,
   WebCore::FramelessScrollView* widget_;
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(WebWidgetImpl);
+  DISALLOW_COPY_AND_ASSIGN(WebWidgetImpl);
 };
 
 #endif  // WEBKIT_GLUE_WEBWIDGET_IMPL_H__