Changeset 226789 in webkit


Ignore:
Timestamp:
Jan 11, 2018, 11:22:46 AM (7 years ago)
Author:
achristensen@apple.com
Message:

Merge sync and async code paths for getting context menus
​https://bugs.webkit.org/show_bug.cgi?id=181423

Reviewed by Joseph Pecoraro.

What a mess. We had a code path for asynchronous context menu generation and a different one for synchronous context menu generation.
This makes it so there is just one. At the API level we see if there is an asynchronous delegate to call, then synchronous.
There is a subtle theoretical change in behaviour because m_page.contextMenuClient().showContextMenu is now called for the asynchronous
case and it wasn't before, but the one C API client that uses this has nullptr as it's WKPageShowContextMenuCallback, so we won't break anything!

  • UIProcess/API/APIContextMenuClient.h:

(API::ContextMenuClient::getContextMenuFromProposedMenu):
(API::ContextMenuClient::getContextMenuFromProposedMenuAsync): Deleted.

  • UIProcess/API/C/WKPage.cpp:

(WKPageSetPageContextMenuClient):

  • UIProcess/API/glib/WebKitContextMenuClient.cpp:
  • UIProcess/WebContextMenuProxy.h:
  • UIProcess/gtk/WebContextMenuProxyGtk.cpp:

(WebKit::WebContextMenuProxyGtk::show):
(WebKit::WebContextMenuProxyGtk::showContextMenuWithItems):

  • UIProcess/gtk/WebContextMenuProxyGtk.h:
  • UIProcess/mac/WebContextMenuProxyMac.h:
  • UIProcess/mac/WebContextMenuProxyMac.mm:

(WebKit::WebContextMenuProxyMac::showContextMenuWithItems):
(WebKit::WebContextMenuProxyMac::showContextMenu):

  • UIProcess/wpe/WebContextMenuProxyWPE.h:
Location:
trunk/Source
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/platform/network/mac/WebCoreResourceHandleAsOperationQueueDelegate.mm

    r225003 r226789  
    4343using namespace WebCore;
    4444
    45 static bool scheduledWithCustomRunLoopMode(SchedulePairHashSet* pairs)
    46 {
    47     if (!pairs)
    48         return false;
    49     for (auto& pair : *pairs) {
    50         auto mode = pair->mode();
    51         if (mode != kCFRunLoopCommonModes && mode != kCFRunLoopDefaultMode)
    52             return true;
    53     }
    54     return false;
    55 }
    56 
    5745@implementation WebCoreResourceHandleAsOperationQueueDelegate
    5846
    … …  
    6553    // This is the common case.
    6654    SchedulePairHashSet* pairs = m_handle && m_handle->context() ? m_handle->context()->scheduledRunLoopPairs() : nullptr;
    67     if (!scheduledWithCustomRunLoopMode(pairs)) {
     55    if (!pairs || pairs->isEmpty()) {
    6856#if PLATFORM(MAC)
    6957        return dispatch_async(dispatch_get_main_queue(), BlockPtr<void()>::fromCallable(WTFMove(function)).get());

  • trunk/Source/WebKit/CMakeLists.txt

    r226494 r226789  
    311311    UIProcess/WebContextConnectionClient.cpp
    312312    UIProcess/WebContextInjectedBundleClient.cpp
     313    UIProcess/WebContextMenuListenerProxy.cpp
    313314    UIProcess/WebContextMenuProxy.cpp
    314315    UIProcess/WebCookieManagerProxy.cpp

  • trunk/Source/WebKit/ChangeLog

    r226779 r226789  
     12018-01-11  Alex Christensen  <achristensen@webkit.org>
     2
     3        Merge sync and async code paths for getting context menus
     4        https://bugs.webkit.org/show_bug.cgi?id=181423
     5
     6        Reviewed by Joseph Pecoraro.
     7
     8        What a mess.  We had a code path for asynchronous context menu generation and a different one for synchronous context menu generation.
     9        This makes it so there is just one.  At the API level we see if there is an asynchronous delegate to call, then synchronous.
     10        There is a subtle theoretical change in behaviour because m_page.contextMenuClient().showContextMenu is now called for the asynchronous
     11        case and it wasn't before, but the one C API client that uses this has nullptr as it's WKPageShowContextMenuCallback, so we won't break anything!
     12
     13        * UIProcess/API/APIContextMenuClient.h:
     14        (API::ContextMenuClient::getContextMenuFromProposedMenu):
     15        (API::ContextMenuClient::getContextMenuFromProposedMenuAsync): Deleted.
     16        * UIProcess/API/C/WKPage.cpp:
     17        (WKPageSetPageContextMenuClient):
     18        * UIProcess/API/glib/WebKitContextMenuClient.cpp:
     19        * UIProcess/WebContextMenuProxy.h:
     20        * UIProcess/gtk/WebContextMenuProxyGtk.cpp:
     21        (WebKit::WebContextMenuProxyGtk::show):
     22        (WebKit::WebContextMenuProxyGtk::showContextMenuWithItems):
     23        * UIProcess/gtk/WebContextMenuProxyGtk.h:
     24        * UIProcess/mac/WebContextMenuProxyMac.h:
     25        * UIProcess/mac/WebContextMenuProxyMac.mm:
     26        (WebKit::WebContextMenuProxyMac::showContextMenuWithItems):
     27        (WebKit::WebContextMenuProxyMac::showContextMenu):
     28        * UIProcess/wpe/WebContextMenuProxyWPE.h:
     29
    1302018-01-11  Wenson Hsieh  <wenson_hsieh@apple.com>
    231

  • trunk/Source/WebKit/PlatformMac.cmake

    r225949 r226789  
    169169    UIProcess/HighPerformanceGraphicsUsageSampler.cpp
    170170    UIProcess/PerActivityStateCPUUsageSampler.cpp
    171     UIProcess/WebContextMenuListenerProxy.cpp
    172171    UIProcess/WebResourceLoadStatisticsStore.cpp
    173172    UIProcess/WebResourceLoadStatisticsTelemetry.cpp

  • trunk/Source/WebKit/UIProcess/API/APIContextMenuClient.h

    r226323 r226789  
    2828#if ENABLE(CONTEXT_MENUS)
    2929
     30#include "WebContextMenuItem.h"
    3031#include "WebContextMenuListenerProxy.h"
    3132#include "WebHitTestResultData.h"
    … …  
    4142
    4243namespace WebKit {
    43 class WebContextMenuItem;
    4444class WebContextMenuItemData;
    4545class WebPageProxy;
    … …  
    5252    virtual ~ContextMenuClient() { }
    5353
    54     virtual bool getContextMenuFromProposedMenu(WebKit::WebPageProxy&, const Vector<Ref<WebKit::WebContextMenuItem>>& /* proposedMenu */, Vector<Ref<WebKit::WebContextMenuItem>>& /* customMenu */, const WebKit::WebHitTestResultData&, API::Object* /* userData */) { return false; }
    55     virtual bool getContextMenuFromProposedMenuAsync(WebKit::WebPageProxy&, const Vector<Ref<WebKit::WebContextMenuItem>>& /* proposedMenu */, WebKit::WebContextMenuListenerProxy*, const WebKit::WebHitTestResultData&, API::Object* /* userData */) { return false; }
     54    virtual void getContextMenuFromProposedMenu(WebKit::WebPageProxy&, Vector<Ref<WebKit::WebContextMenuItem>>&& /* proposedMenu */, WebKit::WebContextMenuListenerProxy& listener, const WebKit::WebHitTestResultData&, API::Object* /* userData */) { listener.useContextMenuItems({ }); }
    5655    virtual void customContextMenuItemSelected(WebKit::WebPageProxy&, const WebKit::WebContextMenuItemData&) { }
    5756    virtual bool showContextMenu(WebKit::WebPageProxy&, const WebCore::IntPoint&, const Vector<Ref<WebKit::WebContextMenuItem>>&) { return false; }

  • trunk/Source/WebKit/UIProcess/API/C/WKPage.cpp

    r226609 r226789  
    819819
    820820    private:
    821         bool getContextMenuFromProposedMenu(WebPageProxy& page, const Vector<Ref<WebKit::WebContextMenuItem>>& proposedMenuVector, Vector<Ref<WebKit::WebContextMenuItem>>& customMenu, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
    822         {
    823             if (!m_client.getContextMenuFromProposedMenu && !m_client.getContextMenuFromProposedMenu_deprecatedForUseWithV0)
    824                 return false;
    825 
    826             if (m_client.base.version >= 2 && !m_client.getContextMenuFromProposedMenu)
    827                 return false;
     821        void getContextMenuFromProposedMenu(WebPageProxy& page, Vector<Ref<WebKit::WebContextMenuItem>>&& proposedMenuVector, WebKit::WebContextMenuListenerProxy& contextMenuListener, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
     822        {
     823            if (m_client.base.version >= 4 && m_client.getContextMenuFromProposedMenuAsync) {
     824                Vector<RefPtr<API::Object>> proposedMenuItems;
     825                proposedMenuItems.reserveInitialCapacity(proposedMenuVector.size());
     826               
     827                for (const auto& menuItem : proposedMenuVector)
     828                    proposedMenuItems.uncheckedAppend(menuItem.ptr());
     829               
     830                auto webHitTestResult = API::HitTestResult::create(hitTestResultData);
     831                m_client.getContextMenuFromProposedMenuAsync(toAPI(&page), toAPI(API::Array::create(WTFMove(proposedMenuItems)).ptr()), toAPI(&contextMenuListener), toAPI(webHitTestResult.ptr()), toAPI(userData), m_client.base.clientInfo);
     832                return;
     833            }
     834           
     835            if (!m_client.getContextMenuFromProposedMenu && !m_client.getContextMenuFromProposedMenu_deprecatedForUseWithV0) {
     836                contextMenuListener.useContextMenuItems(WTFMove(proposedMenuVector));
     837                return;
     838            }
     839
     840            if (m_client.base.version >= 2 && !m_client.getContextMenuFromProposedMenu) {
     841                contextMenuListener.useContextMenuItems(WTFMove(proposedMenuVector));
     842                return;
     843            }
    828844
    829845            Vector<RefPtr<API::Object>> proposedMenuItems;
    … …  
    842858            RefPtr<API::Array> array = adoptRef(toImpl(newMenu));
    843859
    844             customMenu.clear();
    845 
     860            Vector<Ref<WebContextMenuItem>> customMenu;
    846861            size_t newSize = array ? array->size() : 0;
     862            customMenu.reserveInitialCapacity(newSize);
    847863            for (size_t i = 0; i < newSize; ++i) {
    848864                WebContextMenuItem* item = array->at<WebContextMenuItem>(i);
    … …  
    852868                }
    853869
    854                 customMenu.append(*item);
    855             }
    856 
    857             return true;
    858         }
    859 
    860         bool getContextMenuFromProposedMenuAsync(WebPageProxy& page, const Vector<Ref<WebKit::WebContextMenuItem>>& proposedMenuVector, WebKit::WebContextMenuListenerProxy* contextMenuListener, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
    861         {
    862             if (m_client.base.version < 4 || !m_client.getContextMenuFromProposedMenuAsync)
    863                 return false;
    864 
    865             Vector<RefPtr<API::Object>> proposedMenuItems;
    866             proposedMenuItems.reserveInitialCapacity(proposedMenuVector.size());
    867 
    868             for (const auto& menuItem : proposedMenuVector)
    869                 proposedMenuItems.uncheckedAppend(menuItem.ptr());
    870 
    871             RefPtr<API::HitTestResult> webHitTestResult = API::HitTestResult::create(hitTestResultData);
    872             m_client.getContextMenuFromProposedMenuAsync(toAPI(&page), toAPI(API::Array::create(WTFMove(proposedMenuItems)).ptr()), toAPI(contextMenuListener), toAPI(webHitTestResult.get()), toAPI(userData), m_client.base.clientInfo);
    873 
    874             return true;
     870                customMenu.uncheckedAppend(*item);
     871            }
     872
     873            contextMenuListener.useContextMenuItems(WTFMove(customMenu));
    875874        }
    876875

  • trunk/Source/WebKit/UIProcess/API/glib/WebKitContextMenuClient.cpp

    r226323 r226789  
    3535
    3636private:
    37     bool getContextMenuFromProposedMenu(WebPageProxy&, const Vector<Ref<WebContextMenuItem>>& proposedMenu, Vector<Ref<WebContextMenuItem>>&, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
     37    void getContextMenuFromProposedMenu(WebPageProxy&, Vector<Ref<WebKit::WebContextMenuItem>>&& proposedMenu, WebKit::WebContextMenuListenerProxy& contextMenuListener, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
    3838    {
    3939        GRefPtr<GVariant> variant;
    … …  
    4949            menuItems.uncheckedAppend(item->data());
    5050        webkitWebViewPopulateContextMenu(m_webView, menuItems, hitTestResultData, variant.get());
    51         return true;
     51        contextMenuListener.useContextMenuItems({ });
    5252    }
    5353

  • trunk/Source/WebKit/UIProcess/WebContextMenuProxy.h

    r226602 r226789  
    4242    virtual void show() = 0;
    4343
    44     virtual void showContextMenuWithItems(const Vector<Ref<WebContextMenuItem>>&) = 0;
     44    virtual void showContextMenuWithItems(Vector<Ref<WebContextMenuItem>>&&) = 0;
    4545
    4646protected:

  • trunk/Source/WebKit/UIProcess/gtk/WebContextMenuProxyGtk.cpp

    r226602 r226789  
    150150    }
    151151
    152     Vector<Ref<WebContextMenuItem>> clientItems;
    153     bool useProposedItems = true;
    154 
    155     if (m_page->contextMenuClient().getContextMenuFromProposedMenu(*m_page, proposedAPIItems, clientItems, m_context.webHitTestResultData(), m_page->process().transformHandlesToObjects(m_userData.object()).get()))
    156         useProposedItems = false;
    157 
    158     const Vector<Ref<WebContextMenuItem>>& items = useProposedItems ? proposedAPIItems : clientItems;
    159 
     152    m_page->contextMenuClient().getContextMenuFromProposedMenu(*m_page, WTFMove(proposedAPIItems), WebContextMenuListenerProxy::create(this).get(), m_context.webHitTestResultData(), m_page->process().transformHandlesToObjects(m_userData.object()).get());
     153}
     154
     155void WebContextMenuProxyGtk::showContextMenuWithItems(Vector<Ref<WebContextMenuItem>>&& items)
     156{
    160157    if (!items.isEmpty())
    161158        populate(items);
    … …  
    172169    const GdkEvent* event = mouseEvent ? mouseEvent->nativeEvent() : 0;
    173170    gtk_menu_attach_to_widget(m_menu, GTK_WIDGET(m_webView), nullptr);
    174     gtk_menu_popup(m_menu, nullptr, nullptr, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this,
    175                    event ? event->button.button : 3, event ? event->button.time : GDK_CURRENT_TIME);
    176 }
    177 
    178 void WebContextMenuProxyGtk::showContextMenuWithItems(const Vector<Ref<WebContextMenuItem>>&)
    179 {
     171    gtk_menu_popup(m_menu, nullptr, nullptr, reinterpret_cast<GtkMenuPositionFunc>(menuPositionFunction), this, event ? event->button.button : 3, event ? event->button.time : GDK_CURRENT_TIME);
    180172}
    181173

  • trunk/Source/WebKit/UIProcess/gtk/WebContextMenuProxyGtk.h

    r226602 r226789  
    5656    WebContextMenuProxyGtk(GtkWidget*, WebPageProxy&, ContextMenuContextData&&, const UserData&);
    5757    void show() override;
    58     void showContextMenuWithItems(const Vector<Ref<WebContextMenuItem>>&) override;
     58    void showContextMenuWithItems(Vector<Ref<WebContextMenuItem>>&&) override;
    5959    void append(GMenu*, const WebContextMenuItemGlib&);
    6060    GRefPtr<GMenu> buildMenu(const Vector<WebContextMenuItemGlib>&);

  • trunk/Source/WebKit/UIProcess/mac/WebContextMenuProxyMac.h

    r226602 r226789  
    5555
    5656    void contextMenuItemSelected(const WebContextMenuItemData&);
    57     void showContextMenuWithItems(const Vector<Ref<WebContextMenuItem>>&) override;
     57    void showContextMenuWithItems(Vector<Ref<WebContextMenuItem>>&&) override;
    5858
    5959#if ENABLE(SERVICE_CONTROLS)

  • trunk/Source/WebKit/UIProcess/mac/WebContextMenuProxyMac.mm

    r226602 r226789  
    452452}
    453453
    454 void WebContextMenuProxyMac::showContextMenuWithItems(const Vector<Ref<WebContextMenuItem>>& items)
    455 {
     454void WebContextMenuProxyMac::showContextMenuWithItems(Vector<Ref<WebContextMenuItem>>&& items)
     455{
     456    if (m_page.contextMenuClient().showContextMenu(m_page, m_context.menuLocation(), items))
     457        return;
     458
     459    if (items.isEmpty())
     460        return;
     461
    456462    Vector<WebContextMenuItemData> data;
    457463    data.reserveInitialCapacity(items.size());
    … …  
    479485        proposedAPIItems.append(WebContextMenuItem::create(item));
    480486
    481     Vector<Ref<WebContextMenuItem>> clientItems;
    482     bool useProposedItems = true;
    483 
    484487    if (m_contextMenuListener) {
    485488        m_contextMenuListener->invalidate();
    … …  
    489492    m_contextMenuListener = WebContextMenuListenerProxy::create(this);
    490493
    491     if (m_page.contextMenuClient().getContextMenuFromProposedMenuAsync(m_page, proposedAPIItems, m_contextMenuListener.get(), m_context.webHitTestResultData(), m_page.process().transformHandlesToObjects(m_userData.object()).get()))
    492         return;
    493 
    494     // FIXME: Get rid of these two client calls once we don't need to support the C SPI.
    495     if (m_page.contextMenuClient().getContextMenuFromProposedMenu(m_page, proposedAPIItems, clientItems, m_context.webHitTestResultData(), m_page.process().transformHandlesToObjects(m_userData.object()).get()))
    496         useProposedItems = false;
    497 
    498     if (m_page.contextMenuClient().showContextMenu(m_page, m_context.menuLocation(), useProposedItems ? proposedAPIItems : clientItems))
    499         return;
    500 
    501     auto&& items = WTFMove(useProposedItems ? proposedAPIItems : clientItems);
    502    
    503     if (items.isEmpty())
    504         return;
    505 
    506     showContextMenuWithItems(items);
     494    m_page.contextMenuClient().getContextMenuFromProposedMenu(m_page, WTFMove(proposedAPIItems), *m_contextMenuListener, m_context.webHitTestResultData(), m_page.process().transformHandlesToObjects(m_userData.object()).get());
    507495}
    508496

  • trunk/Source/WebKit/UIProcess/wpe/WebContextMenuProxyWPE.h

    r226602 r226789  
    3737    }
    3838
    39     void showContextMenuWithItems(const Vector<Ref<WebContextMenuItem>>&) final { }
     39    void showContextMenuWithItems(Vector<Ref<WebContextMenuItem>>&&) final { }
    4040    void show() final { };
    4141
Note: See TracChangeset for help on using the changeset viewer.