Implement <select> Popup Menu using PagePopup

Source/web/WebViewImpl.cpp

 /*
  * Copyright (C) 2011, 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 128 matching lines @@
 #include "public/web/WebTextInputInfo.h"
 #include "public/web/WebViewClient.h"
 #include "public/web/WebWindowFeatures.h"
 #include "web/CompositionUnderlineVectorBuilder.h"
 #include "web/ContextFeaturesClientImpl.h"
 #include "web/DatabaseClientImpl.h"
 #include "web/FullscreenController.h"
 #include "web/GraphicsLayerFactoryChromium.h"
 #include "web/LinkHighlight.h"
 #include "web/NavigatorContentUtilsClientImpl.h"
-#include "web/PopupContainer.h"
 #include "web/PrerendererClientImpl.h"
 #include "web/StorageQuotaClientImpl.h"
 #include "web/ValidationMessageClientImpl.h"
 #include "web/ViewportAnchor.h"
 #include "web/WebDevToolsAgentImpl.h"
 #include "web/WebDevToolsAgentPrivate.h"
 #include "web/WebInputEventConversion.h"
 #include "web/WebLocalFrameImpl.h"
 #include "web/WebPagePopupImpl.h"
 #include "web/WebPluginContainerImpl.h"
-#include "web/WebPopupMenuImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 #include "web/WebSettingsImpl.h"
 #include "web/WorkerGlobalScopeProxyProviderImpl.h"
 #include "web/painting/ContinuousPainter.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/RefPtr.h"
 #include "wtf/TemporaryChange.h"
 
 #if USE(DEFAULT_RENDER_THEME)
 #include "core/rendering/RenderThemeChromiumDefault.h"
@@ skipping 309 matching lines @@
 {
     m_client->setMouseOverURL(WebURL());
     PageWidgetEventHandler::handleMouseLeave(mainFrame, event);
 }
 
 void WebViewImpl::handleMouseDown(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     // If there is a popup open, close it as the user is clicking on the page (outside of the
     // popup). We also save it so we can prevent a click on an element from immediately
     // reopening the same popup.
-    RefPtrWillBeRawPtr<PopupContainer> selectPopup = nullptr;
     RefPtr<WebPagePopupImpl> pagePopup;
     if (event.button == WebMouseEvent::ButtonLeft) {
-        selectPopup = m_selectPopup;
         pagePopup = m_pagePopup;
         hidePopups();
-        ASSERT(!m_selectPopup);
         ASSERT(!m_pagePopup);
     }
 
     m_lastMouseDownPoint = WebPoint(event.x, event.y);
 
     // Take capture on a mouse down on a plugin so we can send it mouse events.
     // If the hit node is a plugin but a scrollbar is over it don't start mouse
     // capture because it will interfere with the scrollbar receiving events.
     IntPoint point(event.x, event.y);
     if (event.button == WebMouseEvent::ButtonLeft && m_page->mainFrame()->isLocalFrame()) {
         point = m_page->deprecatedLocalMainFrame()->view()->windowToContents(point);
         HitTestResult result(m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(point));
         result.setToShadowHostIfInUserAgentShadowRoot();
         Node* hitNode = result.innerNonSharedNode();
 
         if (!result.scrollbar() && hitNode && hitNode->renderer() && hitNode->renderer()->isEmbeddedObject()) {
             m_mouseCaptureNode = hitNode;
             TRACE_EVENT_ASYNC_BEGIN0("input", "capturing mouse", this);
         }
     }
 
     PageWidgetEventHandler::handleMouseDown(mainFrame, event);
 
     if (event.button == WebMouseEvent::ButtonLeft && m_mouseCaptureNode)
         m_mouseCaptureGestureToken = mainFrame.eventHandler().takeLastMouseDownGestureToken();
 
-    if (m_selectPopup && m_selectPopup == selectPopup) {
-        // That click triggered a select popup which is the same as the one that
-        // was showing before the click.  It means the user clicked the select
-        // while the popup was showing, and as a result we first closed then
-        // immediately reopened the select popup.  It needs to be closed.
-        hideSelectPopup();
-    }
-
     if (m_pagePopup && pagePopup && m_pagePopup->hasSamePopupClient(pagePopup.get())) {
         // That click triggered a page popup that is the same as the one we just closed.
         // It needs to be closed.
         closePagePopup(m_pagePopup.get());
     }
 
     // Dispatch the contextmenu event regardless of if the click was swallowed.
     if (!page()->settings().showContextMenuOnMouseUp()) {
 #if OS(MACOSX)
         if (event.button == WebMouseEvent::ButtonRight
@@ skipping 187 matching lines @@
     }
 
     switch (event.type) {
     case WebInputEvent::GestureTap: {
         m_client->cancelScheduledContentIntents();
         if (detectContentOnTouch(targetedEvent)) {
             eventSwallowed = true;
             break;
         }
 
-        RefPtrWillBeRawPtr<PopupContainer> selectPopup = nullptr;
-        selectPopup = m_selectPopup;
-        hideSelectPopup();
-        ASSERT(!m_selectPopup);
-
         // Don't trigger a disambiguation popup on sites designed for mobile devices.
         // Instead, assume that the page has been designed with big enough buttons and links.
         // Don't trigger a disambiguation popup when screencasting, since it's implemented outside of
         // compositor pipeline and is not being screencasted itself. This leads to bad user experience.
         if (event.data.tap.width > 0 && !shouldDisableDesktopWorkarounds() && !page()->inspectorController().screencastEnabled()) {
             WebGestureEvent scaledEvent = event;
             scaledEvent.x = event.x / pageScaleFactor();
             scaledEvent.y = event.y / pageScaleFactor();
             scaledEvent.data.tap.width = event.data.tap.width / pageScaleFactor();
             scaledEvent.data.tap.height = event.data.tap.height / pageScaleFactor();
@@ skipping 21 matching lines @@
                 for (size_t i = 0; i < m_linkHighlights.size(); ++i)
                     m_linkHighlights[i]->startHighlightAnimationIfNeeded();
                 eventSwallowed = true;
                 eventCancelled = true;
                 break;
             }
         }
 
         eventSwallowed = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(targetedEvent);
 
-        if (m_selectPopup && m_selectPopup == selectPopup) {
-            // That tap triggered a select popup which is the same as the one that
-            // was showing before the tap. It means the user tapped the select
-            // while the popup was showing, and as a result we first closed then
-            // immediately reopened the select popup. It needs to be closed.
-            hideSelectPopup();
-        }
-
         break;
     }
     case WebInputEvent::GestureTwoFingerTap:
     case WebInputEvent::GestureLongPress:
     case WebInputEvent::GestureLongTap: {
         if (!mainFrameImpl() || !mainFrameImpl()->frameView())
             break;
 
         m_client->cancelScheduledContentIntents();
         m_page->contextMenuController().clearContextMenu();
@@ skipping 134 matching lines @@
     endActiveFlingAnimation();
 
     // Please refer to the comments explaining the m_suppressNextKeypressEvent
     // member.
     // The m_suppressNextKeypressEvent is set if the KeyDown is handled by
     // Webkit. A keyDown event is typically associated with a keyPress(char)
     // event and a keyUp event. We reset this flag here as this is a new keyDown
     // event.
     m_suppressNextKeypressEvent = false;
 
-    // If there is a select popup, it should be the one processing the event,
+    // If there is a popup, it should be the one processing the event,
     // not the page.
-    if (m_selectPopup)
-        return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
     if (m_pagePopup) {
         m_pagePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
         // We need to ignore the next Char event after this otherwise pressing
         // enter when selecting an item in the popup will go to the page.
         if (WebInputEvent::RawKeyDown == event.type)
             m_suppressNextKeypressEvent = true;
         return true;
     }
 
     RefPtrWillBeRawPtr<Frame> focusedFrame = focusedCoreFrame();
@@ skipping 45 matching lines @@
     ASSERT(event.type == WebInputEvent::Char);
 
     // Please refer to the comments explaining the m_suppressNextKeypressEvent
     // member.  The m_suppressNextKeypressEvent is set if the KeyDown is
     // handled by Webkit. A keyDown event is typically associated with a
     // keyPress(char) event and a keyUp event. We reset this flag here as it
     // only applies to the current keyPress event.
     bool suppress = m_suppressNextKeypressEvent;
     m_suppressNextKeypressEvent = false;
 
-    // If there is a select popup, it should be the one processing the event,
+    // If there is a popup, it should be the one processing the event,
     // not the page.
-    if (m_selectPopup)
-        return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
     if (m_pagePopup)
         return m_pagePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
 
     LocalFrame* frame = toLocalFrame(focusedCoreFrame());
     if (!frame)
         return suppress;
 
     EventHandler& handler = frame->eventHandler();
 
     PlatformKeyboardEventBuilder evt(event);
@@ skipping 470 matching lines @@
         *scrollDirection = ScrollDown;
         *scrollGranularity = ScrollByPage;
         break;
     default:
         return false;
     }
 
     return true;
 }
 
-void WebViewImpl::hideSelectPopup()
-{
-    if (m_selectPopup)
-        m_selectPopup->hidePopup();
-}
-
-void WebViewImpl::popupOpened(PopupContainer* popupContainer)
-{
-    ASSERT(!m_selectPopup);
-    m_selectPopup = popupContainer;
-    ASSERT(mainFrameImpl()->frame()->document());
-    Document& document = *mainFrameImpl()->frame()->document();
-    page()->frameHost().eventHandlerRegistry().didAddEventHandler(document, EventHandlerRegistry::WheelEvent);
-}
-
-void WebViewImpl::popupClosed(PopupContainer* popupContainer)
-{
-    ASSERT(m_selectPopup);
-    m_selectPopup = nullptr;
-    ASSERT(mainFrameImpl()->frame()->document());
-    Document& document = *mainFrameImpl()->frame()->document();
-    // Remove the handler we added in |popupOpened| conditionally, because the
-    // Document may have already removed it, for instance, due to a navigation.
-    EventHandlerRegistry* registry = &document.frameHost()->eventHandlerRegistry();
-    if (registry->eventHandlerTargets(EventHandlerRegistry::WheelEvent)->contains(&document))
-        registry->didRemoveEventHandler(document, EventHandlerRegistry::WheelEvent);
-}
-
 PagePopup* WebViewImpl::openPagePopup(PagePopupClient* client, const IntRect& originBoundsInRootView)
 {
     ASSERT(client);
     if (hasOpenedPopup())
         hidePopups();
     ASSERT(!m_pagePopup);
 
     WebWidget* popupWidget = m_client->createPopupMenu(WebPopupTypePage);
     ASSERT(popupWidget);
     m_pagePopup = toWebPagePopupImpl(popupWidget);
@@ skipping 2251 matching lines @@
 
     RefPtrWillBeRawPtr<Range> range = Range::create(*startPosition.document(), startPosition, endPosition);
     if (!range)
         return;
 
     clipHtml = createMarkup(range.get(), 0, AnnotateForInterchange, false, ResolveNonLocalURLs);
 }
 
 void WebViewImpl::hidePopups()
 {
-    hideSelectPopup();
     if (m_pagePopup)
         closePagePopup(m_pagePopup.get());
 }
 
 void WebViewImpl::setIsTransparent(bool isTransparent)
 {
     // Set any existing frames to be transparent.
     Frame* frame = m_page->mainFrame();
     while (frame) {
         if (frame->isLocalFrame())
@@ skipping 706 matching lines @@
     return mainFrameImpl()->frameView()->layoutSize().width() == m_size.width
         || (constraints.minimumScale == constraints.maximumScale && constraints.minimumScale != -1);
 }
 
 void WebViewImpl::forceNextWebGLContextCreationToFail()
 {
     WebGLRenderingContext::forceNextWebGLContextCreationToFail();
 }
 
 } // namespace blink