Remove compile time flag ENABLE_PAGE_POPUP . This is part of an overall effort to remove unneeded c…

Source/WebKit/chromium/src/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 522 matching lines @@
     m_client->setMouseOverURL(WebURL());
     PageWidgetEventHandler::handleMouseLeave(mainFrame, event);
 }
 
 void WebViewImpl::handleMouseDown(Frame& 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.
     RefPtr<WebCore::PopupContainer> selectPopup;
-#if ENABLE(PAGE_POPUP)
     RefPtr<WebPagePopupImpl> pagePopup;
-#endif
     if (event.button == WebMouseEvent::ButtonLeft) {
         selectPopup = m_selectPopup;
-#if ENABLE(PAGE_POPUP)
         pagePopup = m_pagePopup;
-#endif
         hidePopups();
         ASSERT(!m_selectPopup);
-#if ENABLE(PAGE_POPUP)
         ASSERT(!m_pagePopup);
-#endif
     }
 
     m_lastMouseDownPoint = WebPoint(event.x, event.y);
 
     if (event.button == WebMouseEvent::ButtonLeft) {
         IntPoint point(event.x, event.y);
         point = m_page->mainFrame()->view()->windowToContents(point);
         HitTestResult result(m_page->mainFrame()->eventHandler()->hitTestResultAtPoint(point));
         Node* hitNode = result.innerNonSharedNode();
 
         // Take capture on a mouse down on a plugin so we can send it mouse events.
         if (hitNode && hitNode->renderer() && hitNode->renderer()->isEmbeddedObject()) {
             m_mouseCaptureNode = hitNode;
             TRACE_EVENT_ASYNC_BEGIN0("webkit", "capturing mouse", this);
         }
     }
 
     PageWidgetEventHandler::handleMouseDown(mainFrame, event);
 
     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 ENABLE(PAGE_POPUP)
     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());
     }
-#endif
 
     // Dispatch the contextmenu event regardless of if the click was swallowed.
     // On Windows, we handle it on mouse up, not down.
 #if OS(DARWIN)
     if (event.button == WebMouseEvent::ButtonRight
         || (event.button == WebMouseEvent::ButtonLeft
             && event.modifiers & WebMouseEvent::ControlKey))
         mouseContextMenu(event);
 #elif OS(UNIX)
     if (event.button == WebMouseEvent::ButtonRight)
@@ skipping 340 matching lines @@
     // 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,
     // not the page.
     if (m_selectPopup)
         return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
-#if ENABLE(PAGE_POPUP)
     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;
     }
-#endif
 
     // Give Autocomplete a chance to consume the key events it is interested in.
     if (autocompleteHandleKeyEvent(event))
         return true;
 
     RefPtr<Frame> frame = focusedWebCoreFrame();
     if (!frame)
         return false;
 
     EventHandler* handler = frame->eventHandler();
@@ skipping 92 matching lines @@
     // 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,
     // not the page.
     if (m_selectPopup)
         return m_selectPopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
-#if ENABLE(PAGE_POPUP)
     if (m_pagePopup)
         return m_pagePopup->handleKeyEvent(PlatformKeyboardEventBuilder(event));
-#endif
 
     Frame* frame = focusedWebCoreFrame();
     if (!frame)
         return suppress;
 
     EventHandler* handler = frame->eventHandler();
     if (!handler)
         return suppress || keyEventDefault(event);
 
     PlatformKeyboardEventBuilder evt(event);
@@ skipping 428 matching lines @@
 }
 
 void  WebViewImpl::popupClosed(WebCore::PopupContainer* popupContainer)
 {
     if (popupContainer->popupType() == WebCore::PopupContainer::Select) {
         ASSERT(m_selectPopup);
         m_selectPopup = 0;
     }
 }
 
-#if ENABLE(PAGE_POPUP)
 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 = static_cast<WebPagePopupImpl*>(popupWidget);
     if (!m_pagePopup->initialize(this, client, originBoundsInRootView)) {
         m_pagePopup->closePopup();
         m_pagePopup = 0;
     }
     return m_pagePopup.get();
 }
 
 void WebViewImpl::closePagePopup(PagePopup* popup)
 {
     ASSERT(popup);
     WebPagePopupImpl* popupImpl = static_cast<WebPagePopupImpl*>(popup);
     ASSERT(m_pagePopup.get() == popupImpl);
     if (m_pagePopup.get() != popupImpl)
         return;
     m_pagePopup->closePopup();
     m_pagePopup = 0;
 }
-#endif
 
 void WebViewImpl::hideAutofillPopup()
 {
     if (m_autofillPopupShowing) {
         m_autofillPopup->hidePopup();
         m_autofillPopupShowing = false;
     }
 }
 
 WebHelperPluginImpl* WebViewImpl::createHelperPlugin(const String& pluginType, const WebDocument& hostDocument)
@@ skipping 1943 matching lines @@
     } else {
         m_autofillPopupShowing = true;
         m_autofillPopup->showInRect(focusedNode->pixelSnappedBoundingBox(), focusedNode->ownerDocument()->view(), 0);
     }
 }
 
 void WebViewImpl::hidePopups()
 {
     hideSelectPopup();
     hideAutofillPopup();
-#if ENABLE(PAGE_POPUP)
     if (m_pagePopup)
         closePagePopup(m_pagePopup.get());
-#endif
 }
 
 void WebViewImpl::performCustomContextMenuAction(unsigned action)
 {
     if (!m_page)
         return;
     ContextMenu* menu = m_page->contextMenuController()->contextMenu();
     if (!menu)
         return;
     const ContextMenuItem* item = menu->itemWithAction(static_cast<ContextMenuAction>(ContextMenuItemBaseCustomTag + action));
@@ skipping 680 matching lines @@
 }
 
 bool WebViewImpl::shouldDisableDesktopWorkarounds()
 {
     ViewportArguments arguments = mainFrameImpl()->frame()->document()->viewportArguments();
     return arguments.width == ViewportArguments::ValueDeviceWidth || !arguments.userZoom
         || (arguments.minZoom == arguments.maxZoom && arguments.minZoom != ViewportArguments::ValueAuto);
 }
 
 } // namespace WebKit