Remove context menus.

sky/engine/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 38 matching lines @@
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/PinchViewport.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLMediaElement.h"
 #include "core/html/ime/InputMethodContext.h"
 #include "core/loader/FrameLoader.h"
 #include "core/loader/UniqueIdentifier.h"
 #include "core/page/Chrome.h"
-#include "core/page/ContextMenuController.h"
-#include "core/page/ContextMenuProvider.h"
 #include "core/page/EventHandler.h"
 #include "core/page/EventWithHitTestResults.h"
 #include "core/page/FocusController.h"
 #include "core/page/Page.h"
 #include "core/page/TouchDisambiguation.h"
 #include "core/rendering/RenderView.h"
 #include "core/rendering/RenderWidget.h"
 #include "core/rendering/compositing/RenderLayerCompositor.h"
-#include "platform/ContextMenu.h"
-#include "platform/ContextMenuItem.h"
 #include "platform/Cursor.h"
 #include "platform/KeyboardCodes.h"
 #include "platform/Logging.h"
 #include "platform/NotImplemented.h"
 #include "platform/PlatformGestureEvent.h"
 #include "platform/PlatformKeyboardEvent.h"
 #include "platform/PlatformMouseEvent.h"
 #include "platform/PlatformWheelEvent.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
@@ skipping 68 matching lines @@
 
 void WebViewImpl::setSpellCheckClient(WebSpellCheckClient* spellCheckClient)
 {
     m_spellCheckClient = spellCheckClient;
 }
 
 WebViewImpl::WebViewImpl(WebViewClient* client)
     : m_client(client)
     , m_spellCheckClient(0)
     , m_chromeClientImpl(this)
-    , m_contextMenuClientImpl(this)
     , m_editorClientImpl(this)
     , m_spellCheckerClientImpl(this)
     , m_fixedLayoutSizeLock(false)
     , m_zoomLevel(0)
     , m_minimumZoomLevel(zoomFactorToZoomLevel(minTextSizeMultiplier))
     , m_maximumZoomLevel(zoomFactorToZoomLevel(maxTextSizeMultiplier))
-    , m_contextMenuAllowed(false)
     , m_doingDragAndDrop(false)
     , m_ignoreInputEvents(false)
     , m_compositorDeviceScaleFactorOverride(0)
     , m_rootLayerScale(1)
     , m_suppressNextKeypressEvent(false)
     , m_imeAcceptEvents(true)
     , m_operationsAllowed(WebDragOperationNone)
     , m_dragOperation(WebDragOperationNone)
     , m_isTransparent(false)
     , m_tabsToLinks(false)
     , m_layerTreeView(0)
     , m_rootLayer(0)
     , m_rootGraphicsLayer(0)
     , m_rootTransformLayer(0)
     , m_graphicsLayerFactory(adoptPtr(new GraphicsLayerFactoryChromium(this)))
     , m_isAcceleratedCompositingActive(false)
     , m_layerTreeViewCommitsDeferred(false)
     , m_layerTreeViewClosed(false)
     , m_matchesHeuristicsForGpuRasterization(false)
-    , m_recreatingGraphicsContext(false)

[ojan, 2014/10/24 00:02:36]

wat

     , m_flingModifier(0)
     , m_flingSourceDevice(false)
     , m_showFPSCounter(false)
     , m_showPaintRects(false)
     , m_showDebugBorders(false)
     , m_continuousPaintingEnabled(false)
     , m_showScrollBottleneckRects(false)
     , m_baseBackgroundColor(Color::white)
     , m_backgroundColorOverride(Color::transparent)
     , m_zoomFactorOverride(0)
     , m_userGestureObserved(false)
 {
     Page::PageClients pageClients;
     pageClients.chromeClient = &m_chromeClientImpl;
-    pageClients.contextMenuClient = &m_contextMenuClientImpl;
     pageClients.editorClient = &m_editorClientImpl;
     pageClients.spellCheckerClient = &m_spellCheckerClientImpl;
 
     m_page = adoptPtrWillBeNoop(new Page(pageClients));
     m_page->makeOrdinary();
 
     setDeviceScaleFactor(m_client->screenInfo().deviceScaleFactor);
     setVisibilityState(m_client->visibilityState(), true);
 
     m_layerTreeView = m_client->initializeLayerTreeView();
@@ skipping 28 matching lines @@
 }
 
 void WebViewImpl::handleMouseDown(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     m_lastMouseDownPoint = WebPoint(event.x, event.y);
 
     PageWidgetEventHandler::handleMouseDown(mainFrame, event);
 
     if (event.button == WebMouseEvent::ButtonLeft && m_mouseCaptureNode)
         m_mouseCaptureGestureToken = mainFrame.eventHandler().takeLastMouseDownGestureToken();
-
-    // Dispatch the contextmenu event regardless of if the click was swallowed.
-#if OS(MACOSX)
-    if (event.button == WebMouseEvent::ButtonRight
-        || (event.button == WebMouseEvent::ButtonLeft
-            && event.modifiers & WebMouseEvent::ControlKey))
-        mouseContextMenu(event);
-#else
-    if (event.button == WebMouseEvent::ButtonRight)
-        mouseContextMenu(event);
-#endif
-}
-
-void WebViewImpl::mouseContextMenu(const WebMouseEvent& event)
-{
-    if (!mainFrameImpl() || !mainFrameImpl()->frameView())
-        return;
-
-    m_page->contextMenuController().clearContextMenu();
-
-    PlatformMouseEventBuilder pme(mainFrameImpl()->frameView(), event);
-
-    // Find the right target frame. See issue 1186900.
-    HitTestResult result = hitTestResultForWindowPos(pme.position());
-    LocalFrame* targetFrame;
-    if (result.innerNonSharedNode())
-        targetFrame = result.innerNonSharedNode()->document().frame();
-    else
-        targetFrame = m_page->focusController().focusedOrMainFrame();
-
-    LocalFrame* targetLocalFrame = targetFrame;
-
-    m_contextMenuAllowed = true;
-    targetLocalFrame->eventHandler().sendContextMenuEvent(pme);
-    m_contextMenuAllowed = false;
-    // Actually showing the context menu is handled by the ContextMenuClient
-    // implementation...
 }
 
 void WebViewImpl::handleMouseUp(LocalFrame& mainFrame, const WebMouseEvent& event)
 {
     PageWidgetEventHandler::handleMouseUp(mainFrame, event);
-
-#if OS(WIN)
-    // Dispatch the contextmenu event regardless of if the click was swallowed.
-    // On Mac/Linux, we handle it on mouse down, not up.
-    if (event.button == WebMouseEvent::ButtonRight)
-        mouseContextMenu(event);
-#endif
 }
 
 bool WebViewImpl::handleMouseWheel(LocalFrame& mainFrame, const WebMouseWheelEvent& event)
 {
     return PageWidgetEventHandler::handleMouseWheel(mainFrame, event);
 }
 
 bool WebViewImpl::scrollBy(const WebFloatSize& delta, const WebFloatSize& velocity)
 {
     if (m_flingSourceDevice == WebGestureDeviceTouchpad) {
@@ skipping 121 matching lines @@
         eventSwallowed = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(platformEvent);
         break;
     }
     case WebInputEvent::GestureTwoFingerTap:
     case WebInputEvent::GestureLongPress:
     case WebInputEvent::GestureLongTap: {
         if (!mainFrameImpl() || !mainFrameImpl()->frameView())
             break;
 
         m_client->cancelScheduledContentIntents();
-        m_page->contextMenuController().clearContextMenu();
-        m_contextMenuAllowed = true;
         eventSwallowed = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(platformEvent);
-        m_contextMenuAllowed = false;
-
         break;
     }
     case WebInputEvent::GestureShowPress: {
         m_client->cancelScheduledContentIntents();
         eventSwallowed = mainFrameImpl()->frame()->eventHandler().handleGestureEvent(platformEvent);
         break;
     }
     case WebInputEvent::GestureDoubleTap:
         // GestureDoubleTap is currently only used by Android for zooming. For WebCore,
         // GestureTap with tap count = 2 is used instead. So we drop GestureDoubleTap here.
@@ skipping 137 matching lines @@
 
     if (frame->eventHandler().keyEvent(evt)) {
         if (WebInputEvent::RawKeyDown == event.type) {
             // Suppress the next keypress event unless the focused node is a plug-in node.
             // (Flash needs these keypress events to handle non-US keyboards.)
             m_suppressNextKeypressEvent = true;
         }
         return true;
     }
 
-#if !OS(MACOSX)
-    const WebInputEvent::Type contextMenuTriggeringEventType =
-#if OS(WIN)
-        WebInputEvent::KeyUp;
-#else
-        WebInputEvent::RawKeyDown;
-#endif
-
-    bool isUnmodifiedMenuKey = !(event.modifiers & WebInputEvent::InputModifiers) && event.windowsKeyCode == VKEY_APPS;
-    bool isShiftF10 = event.modifiers == WebInputEvent::ShiftKey && event.windowsKeyCode == VKEY_F10;
-    if ((isUnmodifiedMenuKey || isShiftF10) && event.type == contextMenuTriggeringEventType) {
-        sendContextMenuEvent(event);
-        return true;
-    }
-#endif // !OS(MACOSX)
-
     return keyEventDefault(event);
 }
 
 bool WebViewImpl::handleCharEvent(const WebKeyboardEvent& event)
 {
     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
@@ skipping 227 matching lines @@
 {
     m_client->hasTouchEventHandlers(hasTouchHandlers);
 }
 
 bool WebViewImpl::hasTouchEventHandlersAt(const WebPoint& point)
 {
     // FIXME: Implement this. Note that the point must be divided by pageScaleFactor.
     return true;
 }
 
-#if !OS(MACOSX)
-// Mac has no way to open a context menu based on a keyboard event.
-bool WebViewImpl::sendContextMenuEvent(const WebKeyboardEvent& event)
-{
-    // The contextMenuController() holds onto the last context menu that was
-    // popped up on the page until a new one is created. We need to clear
-    // this menu before propagating the event through the DOM so that we can
-    // detect if we create a new menu for this event, since we won't create
-    // a new menu if the DOM swallows the event and the defaultEventHandler does
-    // not run.
-    page()->contextMenuController().clearContextMenu();
-
-    m_contextMenuAllowed = true;
-    LocalFrame* focusedFrame = page()->focusController().focusedOrMainFrame();
-    bool handled = focusedFrame->eventHandler().sendContextMenuEventForKey();
-    m_contextMenuAllowed = false;
-    return handled;
-}
-#endif
-
-void WebViewImpl::showContextMenuAtPoint(float x, float y, PassRefPtr<ContextMenuProvider> menuProvider)
-{
-    m_contextMenuAllowed = true;
-    page()->contextMenuController().clearContextMenu();
-    page()->contextMenuController().showContextMenuAtPoint(page()->mainFrame(), x, y, menuProvider);
-    m_contextMenuAllowed = false;
-}
-
 bool WebViewImpl::keyEventDefault(const WebKeyboardEvent& event)
 {
     LocalFrame* frame = focusedCoreFrame();
     if (!frame)
         return false;
 
     switch (event.type) {
     case WebInputEvent::Char:
         if (event.windowsKeyCode == VKEY_SPACE) {
             int keyCode = ((event.modifiers & WebInputEvent::ShiftKey) ? VKEY_PRIOR : VKEY_NEXT);
@@ skipping 322 matching lines @@
     case WebInputEvent::MouseDown:
         return EventTypeNames::mousedown;
     case WebInputEvent::MouseUp:
         return EventTypeNames::mouseup;
     case WebInputEvent::MouseMove:
         return EventTypeNames::mousemove;
     case WebInputEvent::MouseEnter:
         return EventTypeNames::mouseenter;
     case WebInputEvent::MouseLeave:
         return EventTypeNames::mouseleave;
-    case WebInputEvent::ContextMenu:
-        return EventTypeNames::contextmenu;
     case WebInputEvent::MouseWheel:
         return EventTypeNames::mousewheel;
     case WebInputEvent::KeyDown:
         return EventTypeNames::keydown;
     case WebInputEvent::KeyUp:
         return EventTypeNames::keyup;
     case WebInputEvent::GestureScrollBegin:
         return EventTypeNames::gesturescrollstart;
     case WebInputEvent::GestureScrollEnd:
         return EventTypeNames::gesturescrollend;
@@ skipping 965 matching lines @@
 {
     if (m_rootLayerScale == rootLayerScale && m_rootLayerOffset == rootLayerOffset)
         return;
     m_rootLayerScale = rootLayerScale;
     m_rootLayerOffset = rootLayerOffset;
     if (mainFrameImpl())
         mainFrameImpl()->setInputEventsTransformForEmulation(m_rootLayerOffset, m_rootLayerScale);
     updateRootLayerTransform();
 }
 
-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));
-    if (item)
-        m_page->contextMenuController().contextMenuItemSelected(item);
-    m_page->contextMenuController().clearContextMenu();
-}
-
-void WebViewImpl::showContextMenu()
-{
-    if (!page())
-        return;
-
-    page()->contextMenuController().clearContextMenu();
-    m_contextMenuAllowed = true;
-    if (LocalFrame* focusedFrame = page()->focusController().focusedOrMainFrame())
-        focusedFrame->eventHandler().sendContextMenuEventForKey();
-    m_contextMenuAllowed = false;
-}
-
 void WebViewImpl::extractSmartClipData(WebRect rect, WebString& clipText, WebString& clipHtml, WebRect& clipRect)
 {
 }
 
 void WebViewImpl::setIsTransparent(bool isTransparent)
 {
     // Set any existing frames to be transparent.
     m_page->mainFrame()->view()->setTransparent(isTransparent);
 
     // Future frames check this to know whether to be transparent.
@@ skipping 428 matching lines @@
         m_layerTreeView->setVisible(visible);
     }
 }
 
 bool WebViewImpl::shouldDisableDesktopWorkarounds()
 {
     return true;
 }
 
 } // namespace blink