Changeset 226323 in webkit


Ignore:
Timestamp:
Jan 2, 2018 9:17:19 AM (6 years ago)
Author:
achristensen@apple.com
Message:

Clean up context menu code
​https://bugs.webkit.org/show_bug.cgi?id=181074

Reviewed by Brent Fulgham.

Use Ref instead of RefPtr where possible.
Use move semantics instead of copying from const references when possible.
Remove dead iOS code. Reduce allocations. Add stub for WPE.

  • UIProcess/API/APIContextMenuClient.h:

(API::ContextMenuClient::getContextMenuFromProposedMenu):
(API::ContextMenuClient::getContextMenuFromProposedMenuAsync):
(API::ContextMenuClient::showContextMenu):

  • UIProcess/API/C/WKPage.cpp:

(WKPageSetPageContextMenuClient):

  • UIProcess/API/gtk/PageClientImpl.cpp:

(WebKit::PageClientImpl::createContextMenuProxy):

  • UIProcess/API/gtk/PageClientImpl.h:
  • UIProcess/PageClient.h:
  • UIProcess/WebContextMenuListenerProxy.cpp:

(WebKit::WebContextMenuListenerProxy::useContextMenuItems):

  • UIProcess/WebContextMenuProxy.cpp:

(WebKit::WebContextMenuProxy::WebContextMenuProxy):

  • UIProcess/WebContextMenuProxy.h:
  • UIProcess/WebPageProxy.cpp:

(WebKit::WebPageProxy::showContextMenu):
(WebKit::WebPageProxy::internalShowContextMenu): Deleted.

  • UIProcess/WebPageProxy.h:
  • UIProcess/gtk/WebContextMenuProxyGtk.cpp:

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

  • UIProcess/gtk/WebContextMenuProxyGtk.h:

(WebKit::WebContextMenuProxyGtk::create):

  • UIProcess/ios/PageClientImplIOS.h:
  • UIProcess/ios/PageClientImplIOS.mm:

(WebKit::PageClientImpl::createContextMenuProxy): Deleted.

  • UIProcess/mac/PageClientImplMac.h:
  • UIProcess/mac/PageClientImplMac.mm:

(WebKit::PageClientImpl::createContextMenuProxy):

  • UIProcess/mac/WebContextMenuProxyMac.h:

(WebKit::WebContextMenuProxyMac::create):

  • UIProcess/mac/WebContextMenuProxyMac.mm:

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

Location:
trunk/Source/WebKit
Files:
1 added
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r226320 r226323  
     12018-01-02  Alex Christensen  <achristensen@webkit.org>
     2
     3        Clean up context menu code
     4        https://bugs.webkit.org/show_bug.cgi?id=181074
     5
     6        Reviewed by Brent Fulgham.
     7
     8        Use Ref instead of RefPtr where possible.
     9        Use move semantics instead of copying from const references when possible.
     10        Remove dead iOS code.  Reduce allocations.  Add stub for WPE.
     11
     12        * UIProcess/API/APIContextMenuClient.h:
     13        (API::ContextMenuClient::getContextMenuFromProposedMenu):
     14        (API::ContextMenuClient::getContextMenuFromProposedMenuAsync):
     15        (API::ContextMenuClient::showContextMenu):
     16        * UIProcess/API/C/WKPage.cpp:
     17        (WKPageSetPageContextMenuClient):
     18        * UIProcess/API/gtk/PageClientImpl.cpp:
     19        (WebKit::PageClientImpl::createContextMenuProxy):
     20        * UIProcess/API/gtk/PageClientImpl.h:
     21        * UIProcess/PageClient.h:
     22        * UIProcess/WebContextMenuListenerProxy.cpp:
     23        (WebKit::WebContextMenuListenerProxy::useContextMenuItems):
     24        * UIProcess/WebContextMenuProxy.cpp:
     25        (WebKit::WebContextMenuProxy::WebContextMenuProxy):
     26        * UIProcess/WebContextMenuProxy.h:
     27        * UIProcess/WebPageProxy.cpp:
     28        (WebKit::WebPageProxy::showContextMenu):
     29        (WebKit::WebPageProxy::internalShowContextMenu): Deleted.
     30        * UIProcess/WebPageProxy.h:
     31        * UIProcess/gtk/WebContextMenuProxyGtk.cpp:
     32        (WebKit::WebContextMenuProxyGtk::showContextMenuWithItems):
     33        (WebKit::WebContextMenuProxyGtk::WebContextMenuProxyGtk):
     34        * UIProcess/gtk/WebContextMenuProxyGtk.h:
     35        (WebKit::WebContextMenuProxyGtk::create):
     36        * UIProcess/ios/PageClientImplIOS.h:
     37        * UIProcess/ios/PageClientImplIOS.mm:
     38        (WebKit::PageClientImpl::createContextMenuProxy): Deleted.
     39        * UIProcess/mac/PageClientImplMac.h:
     40        * UIProcess/mac/PageClientImplMac.mm:
     41        (WebKit::PageClientImpl::createContextMenuProxy):
     42        * UIProcess/mac/WebContextMenuProxyMac.h:
     43        (WebKit::WebContextMenuProxyMac::create):
     44        * UIProcess/mac/WebContextMenuProxyMac.mm:
     45        (WebKit::WebContextMenuProxyMac::WebContextMenuProxyMac):
     46        (WebKit::WebContextMenuProxyMac::showContextMenuWithItems):
     47        (WebKit::WebContextMenuProxyMac::showContextMenu):
     48
    149== Rolled over to ChangeLog-2018-01-01 ==

  • trunk/Source/WebKit/PlatformWPE.cmake

    r226268 r226323  
    426426    "${WEBKIT_DIR}/UIProcess/linux"
    427427    "${WEBKIT_DIR}/UIProcess/soup"
     428    "${WEBKIT_DIR}/UIProcess/wpe"
    428429    "${WEBKIT_DIR}/WebProcess/InjectedBundle/API/glib"
    429430    "${WEBKIT_DIR}/WebProcess/InjectedBundle/API/wpe"

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

    r222113 r226323  
    2424 */
    2525
    26 #ifndef APIContextMenuClient_h
    27 #define APIContextMenuClient_h
     26#pragma once
    2827
    2928#if ENABLE(CONTEXT_MENUS)
    … …  
    5352    virtual ~ContextMenuClient() { }
    5453
    55     virtual bool getContextMenuFromProposedMenu(WebKit::WebPageProxy&, const Vector<RefPtr<WebKit::WebContextMenuItem>>& /* proposedMenu */, Vector<RefPtr<WebKit::WebContextMenuItem>>& /* customMenu */, const WebKit::WebHitTestResultData&, API::Object* /* userData */) { return false; }
    56     virtual bool getContextMenuFromProposedMenuAsync(WebKit::WebPageProxy&, const Vector<RefPtr<WebKit::WebContextMenuItem>>& /* proposedMenu */, WebKit::WebContextMenuListenerProxy*, const WebKit::WebHitTestResultData&, API::Object* /* userData */) { return false; }
     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; }
    5756    virtual void customContextMenuItemSelected(WebKit::WebPageProxy&, const WebKit::WebContextMenuItemData&) { }
    58     virtual bool showContextMenu(WebKit::WebPageProxy&, const WebCore::IntPoint&, const Vector<RefPtr<WebKit::WebContextMenuItem>>&) { return false; }
     57    virtual bool showContextMenu(WebKit::WebPageProxy&, const WebCore::IntPoint&, const Vector<Ref<WebKit::WebContextMenuItem>>&) { return false; }
    5958    virtual bool hideContextMenu(WebKit::WebPageProxy&) { return false; }
    6059
    … …  
    6766
    6867#endif // ENABLE(CONTEXT_MENUS)
    69 #endif // APIContextMenuClient_h

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

    r225989 r226323  
    819819
    820820    private:
    821         bool getContextMenuFromProposedMenu(WebPageProxy& page, const Vector<RefPtr<WebKit::WebContextMenuItem>>& proposedMenuVector, Vector<RefPtr<WebKit::WebContextMenuItem>>& customMenu, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
     821        bool getContextMenuFromProposedMenu(WebPageProxy& page, const Vector<Ref<WebKit::WebContextMenuItem>>& proposedMenuVector, Vector<Ref<WebKit::WebContextMenuItem>>& customMenu, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
    822822        {
    823823            if (!m_client.getContextMenuFromProposedMenu && !m_client.getContextMenuFromProposedMenu_deprecatedForUseWithV0)
    … …  
    831831
    832832            for (const auto& menuItem : proposedMenuVector)
    833                 proposedMenuItems.uncheckedAppend(menuItem);
     833                proposedMenuItems.uncheckedAppend(menuItem.ptr());
    834834
    835835            WKArrayRef newMenu = nullptr;
    836836            if (m_client.base.version >= 2) {
    837                 RefPtr<API::HitTestResult> webHitTestResult = API::HitTestResult::create(hitTestResultData);
    838                 m_client.getContextMenuFromProposedMenu(toAPI(&page), toAPI(API::Array::create(WTFMove(proposedMenuItems)).ptr()), &newMenu, toAPI(webHitTestResult.get()), toAPI(userData), m_client.base.clientInfo);
     837                auto webHitTestResult = API::HitTestResult::create(hitTestResultData);
     838                m_client.getContextMenuFromProposedMenu(toAPI(&page), toAPI(API::Array::create(WTFMove(proposedMenuItems)).ptr()), &newMenu, toAPI(webHitTestResult.ptr()), toAPI(userData), m_client.base.clientInfo);
    839839            } else
    840840                m_client.getContextMenuFromProposedMenu_deprecatedForUseWithV0(toAPI(&page), toAPI(API::Array::create(WTFMove(proposedMenuItems)).ptr()), &newMenu, toAPI(userData), m_client.base.clientInfo);
    … …  
    852852                }
    853853
    854                 customMenu.append(item);
     854                customMenu.append(*item);
    855855            }
    856856
    … …  
    858858        }
    859859
    860         bool getContextMenuFromProposedMenuAsync(WebPageProxy& page, const Vector<RefPtr<WebKit::WebContextMenuItem>>& proposedMenuVector, WebKit::WebContextMenuListenerProxy* contextMenuListener, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
     860        bool getContextMenuFromProposedMenuAsync(WebPageProxy& page, const Vector<Ref<WebKit::WebContextMenuItem>>& proposedMenuVector, WebKit::WebContextMenuListenerProxy* contextMenuListener, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
    861861        {
    862862            if (m_client.base.version < 4 || !m_client.getContextMenuFromProposedMenuAsync)
    … …  
    867867
    868868            for (const auto& menuItem : proposedMenuVector)
    869                 proposedMenuItems.uncheckedAppend(menuItem);
     869                proposedMenuItems.uncheckedAppend(menuItem.ptr());
    870870
    871871            RefPtr<API::HitTestResult> webHitTestResult = API::HitTestResult::create(hitTestResultData);
    … …  
    883883        }
    884884
    885         bool showContextMenu(WebPageProxy& page, const WebCore::IntPoint& menuLocation, const Vector<RefPtr<WebContextMenuItem>>& menuItemsVector) override
     885        bool showContextMenu(WebPageProxy& page, const WebCore::IntPoint& menuLocation, const Vector<Ref<WebContextMenuItem>>& menuItemsVector) override
    886886        {
    887887            if (!m_client.showContextMenu)
    … …  
    892892
    893893            for (const auto& menuItem : menuItemsVector)
    894                 menuItems.uncheckedAppend(menuItem);
     894                menuItems.uncheckedAppend(menuItem.ptr());
    895895
    896896            m_client.showContextMenu(toAPI(&page), toAPI(menuLocation), toAPI(API::Array::create(WTFMove(menuItems)).ptr()), m_client.base.clientInfo);

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

    r218487 r226323  
    3535
    3636private:
    37     bool getContextMenuFromProposedMenu(WebPageProxy&, const Vector<RefPtr<WebContextMenuItem>>& proposedMenu, Vector<RefPtr<WebContextMenuItem>>&, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
     37    bool getContextMenuFromProposedMenu(WebPageProxy&, const Vector<Ref<WebContextMenuItem>>& proposedMenu, Vector<Ref<WebContextMenuItem>>&, const WebHitTestResultData& hitTestResultData, API::Object* userData) override
    3838    {
    3939        GRefPtr<GVariant> variant;

  • trunk/Source/WebKit/UIProcess/API/gtk/PageClientImpl.cpp

    r222855 r226323  
    212212}
    213213
    214 RefPtr<WebContextMenuProxy> PageClientImpl::createContextMenuProxy(WebPageProxy& page, const ContextMenuContextData& context, const UserData& userData)
    215 {
    216     return WebContextMenuProxyGtk::create(m_viewWidget, page, context, userData);
     214Ref<WebContextMenuProxy> PageClientImpl::createContextMenuProxy(WebPageProxy& page, ContextMenuContextData&& context, const UserData& userData)
     215{
     216    return WebContextMenuProxyGtk::create(m_viewWidget, page, WTFMove(context), userData);
    217217}
    218218

  • trunk/Source/WebKit/UIProcess/API/gtk/PageClientImpl.h

    r221489 r226323  
    8181    void doneWithKeyEvent(const NativeWebKeyboardEvent&, bool wasEventHandled) override;
    8282    RefPtr<WebPopupMenuProxy> createPopupMenuProxy(WebPageProxy&) override;
    83     RefPtr<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, const ContextMenuContextData&, const UserData&) override;
     83    Ref<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, ContextMenuContextData&&, const UserData&) override;
    8484#if ENABLE(INPUT_TYPE_COLOR)
    8585    RefPtr<WebColorPicker> createColorPicker(WebPageProxy*, const WebCore::Color& intialColor, const WebCore::IntRect&) override;

  • trunk/Source/WebKit/UIProcess/API/wpe/PageClientImpl.cpp

    r218740 r226323  
    3333#include "WPEView.h"
    3434#include "WebContextMenuProxy.h"
     35#include "WebContextMenuProxyWPE.h"
    3536#include <WebCore/ActivityState.h>
    3637#include <WebCore/NotImplemented.h>
    … …  
    231232
    232233#if ENABLE(CONTEXT_MENUS)
    233 RefPtr<WebContextMenuProxy> PageClientImpl::createContextMenuProxy(WebPageProxy&, const ContextMenuContextData&, const UserData&)
    234 {
    235     return nullptr;
     234Ref<WebContextMenuProxy> PageClientImpl::createContextMenuProxy(WebPageProxy&, ContextMenuContextData&& context, const UserData& userData)
     235{
     236    return WebContextMenuProxyWPE::create(WTFMove(context), userData);
    236237}
    237238#endif

  • trunk/Source/WebKit/UIProcess/API/wpe/PageClientImpl.h

    r222729 r226323  
    8484    RefPtr<WebPopupMenuProxy> createPopupMenuProxy(WebPageProxy&) override;
    8585#if ENABLE(CONTEXT_MENUS)
    86     RefPtr<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, const ContextMenuContextData&, const UserData&) override;
     86    Ref<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, ContextMenuContextData&&, const UserData&) override;
    8787#endif
    8888

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

    r226312 r226323  
    215215    virtual RefPtr<WebPopupMenuProxy> createPopupMenuProxy(WebPageProxy&) = 0;
    216216#if ENABLE(CONTEXT_MENUS)
    217     virtual RefPtr<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, const ContextMenuContextData&, const UserData&) = 0;
     217    virtual Ref<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, ContextMenuContextData&&, const UserData&) = 0;
    218218#endif
    219219

  • trunk/Source/WebKit/UIProcess/WebContextMenuListenerProxy.cpp

    r217531 r226323  
    5454
    5555    RefPtr<API::Array> array = toImpl(items);
     56    size_t newSize = array ? array->size() : 0;
    5657    Vector<WebContextMenuItemData> dataItems;
    57 
    58     size_t newSize = array ? array->size() : 0;
     58    dataItems.reserveInitialCapacity(newSize);
    5959    for (size_t i = 0; i < newSize; ++i) {
    6060        WebContextMenuItem* item = array->at<WebContextMenuItem>(i);
    … …  
    6262            continue;
    6363
    64         dataItems.append(item->data());
     64        dataItems.uncheckedAppend(item->data());
    6565    }
    6666
    67     m_contextMenuMac->showContextMenuWithItems(dataItems);
     67    m_contextMenuMac->showContextMenuWithItems(WTFMove(dataItems));
    6868}
    6969

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

    r191146 r226323  
    3131namespace WebKit {
    3232
    33 WebContextMenuProxy::WebContextMenuProxy(const ContextMenuContextData& context, const UserData& userData)
    34     : m_context(context)
     33WebContextMenuProxy::WebContextMenuProxy(ContextMenuContextData&& context, const UserData& userData)
     34    : m_context(WTFMove(context))
    3535    , m_userData(userData)
    3636{

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

    r217552 r226323  
    4242    virtual void show() = 0;
    4343
    44     virtual void showContextMenuWithItems(const Vector<WebContextMenuItemData>& items) = 0;
     44    virtual void showContextMenuWithItems(Vector<WebContextMenuItemData>&&) = 0;
    4545
    4646protected:
    47     WebContextMenuProxy(const ContextMenuContextData&, const UserData&);
     47    WebContextMenuProxy(ContextMenuContextData&&, const UserData&);
    4848
    4949    const ContextMenuContextData m_context;

  • trunk/Source/WebKit/UIProcess/WebPageProxy.cpp

    r226235 r226323  
    47234723
    47244724#if ENABLE(CONTEXT_MENUS)
    4725 void WebPageProxy::showContextMenu(const ContextMenuContextData& contextMenuContextData, const UserData& userData)
     4725void WebPageProxy::showContextMenu(ContextMenuContextData&& contextMenuContextData, const UserData& userData)
    47264726{
    47274727    // Showing a context menu runs a nested runloop, which can handle messages that cause |this| to get closed.
    47284728    Ref<WebPageProxy> protect(*this);
    47294729
    4730     internalShowContextMenu(contextMenuContextData, userData);
    4731    
    4732     // No matter the result of internalShowContextMenu, always notify the WebProcess that the menu is hidden so it starts handling mouse events again.
    4733     m_process->send(Messages::WebPage::ContextMenuHidden(), m_pageID);
    4734 }
    4735 
    4736 void WebPageProxy::internalShowContextMenu(const ContextMenuContextData& contextMenuContextData, const UserData& userData)
    4737 {
    47384730    m_activeContextMenuContextData = contextMenuContextData;
    47394731
    4740     m_activeContextMenu = m_pageClient.createContextMenuProxy(*this, contextMenuContextData, userData);
    4741     if (!m_activeContextMenu)
    4742         return;
     4732    m_activeContextMenu = m_pageClient.createContextMenuProxy(*this, WTFMove(contextMenuContextData), userData);
    47434733
    47444734    // Since showContextMenu() can spin a nested run loop we need to turn off the responsiveness timer.
    … …  
    47484738    Ref<WebContextMenuProxy> protector(*m_activeContextMenu);
    47494739    m_activeContextMenu->show();
     4740
     4741    // No matter the result of internalShowContextMenu, always notify the WebProcess that the menu is hidden so it starts handling mouse events again.
     4742    m_process->send(Messages::WebPage::ContextMenuHidden(), m_pageID);
    47504743}
    47514744

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

    r226312 r226323  
    14621462
    14631463#if ENABLE(CONTEXT_MENUS)
    1464     void showContextMenu(const ContextMenuContextData&, const UserData&);
    1465     void internalShowContextMenu(const ContextMenuContextData&, const UserData&);
     1464    void showContextMenu(ContextMenuContextData&&, const UserData&);
    14661465#endif
    14671466

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

    r218798 r226323  
    125125}
    126126
    127 void WebContextMenuProxyGtk::populate(const Vector<RefPtr<WebContextMenuItem>>& items)
     127void WebContextMenuProxyGtk::populate(const Vector<Ref<WebContextMenuItem>>& items)
    128128{
    129129    GRefPtr<GMenu> menu = adoptGRef(g_menu_new());
    … …  
    144144void WebContextMenuProxyGtk::show()
    145145{
    146     Vector<RefPtr<WebContextMenuItem>> proposedAPIItems;
     146    Vector<Ref<WebContextMenuItem>> proposedAPIItems;
    147147    for (auto& item : m_context.menuItems()) {
    148148        if (item.action() != ContextMenuItemTagShareMenu)
    … …  
    150150    }
    151151
    152     Vector<RefPtr<WebContextMenuItem>> clientItems;
     152    Vector<Ref<WebContextMenuItem>> clientItems;
    153153    bool useProposedItems = true;
    154154
    … …  
    156156        useProposedItems = false;
    157157
    158     const Vector<RefPtr<WebContextMenuItem>>& items = useProposedItems ? proposedAPIItems : clientItems;
     158    const Vector<Ref<WebContextMenuItem>>& items = useProposedItems ? proposedAPIItems : clientItems;
    159159
    160160    if (!items.isEmpty())
    … …  
    176176}
    177177
    178 void WebContextMenuProxyGtk::showContextMenuWithItems(const Vector<WebContextMenuItemData>& items)
    179 {
    180 }
    181 
    182 WebContextMenuProxyGtk::WebContextMenuProxyGtk(GtkWidget* webView, WebPageProxy& page, const ContextMenuContextData& context, const UserData& userData)
    183     : WebContextMenuProxy(context, userData)
     178void WebContextMenuProxyGtk::showContextMenuWithItems(Vector<WebContextMenuItemData>&&)
     179{
     180}
     181
     182WebContextMenuProxyGtk::WebContextMenuProxyGtk(GtkWidget* webView, WebPageProxy& page, ContextMenuContextData&& context, const UserData& userData)
     183    : WebContextMenuProxy(WTFMove(context), userData)
    184184    , m_webView(webView)
    185185    , m_page(&page)

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

    r218445 r226323  
    2424 */
    2525
    26 #ifndef WebContextMenuProxyGtk_h
    27 #define WebContextMenuProxyGtk_h
     26#pragma once
    2827
    2928#if ENABLE(CONTEXT_MENUS)
    … …  
    4544class WebContextMenuProxyGtk : public WebContextMenuProxy {
    4645public:
    47     static auto create(GtkWidget* widget, WebPageProxy& page, const ContextMenuContextData& context, const UserData& userData)
     46    static auto create(GtkWidget* widget, WebPageProxy& page, ContextMenuContextData&& context, const UserData& userData)
    4847    {
    49         return adoptRef(*new WebContextMenuProxyGtk(widget, page, context, userData));
     48        return adoptRef(*new WebContextMenuProxyGtk(widget, page, WTFMove(context), userData));
    5049    }
    5150    ~WebContextMenuProxyGtk();
    … …  
    5554
    5655private:
    57     WebContextMenuProxyGtk(GtkWidget*, WebPageProxy&, const ContextMenuContextData&, const UserData&);
     56    WebContextMenuProxyGtk(GtkWidget*, WebPageProxy&, ContextMenuContextData&&, const UserData&);
    5857    void show() override;
    59     void showContextMenuWithItems(const Vector<WebContextMenuItemData>&) override;
     58    void showContextMenuWithItems(Vector<WebContextMenuItemData>&&) override;
    6059    void append(GMenu*, const WebContextMenuItemGlib&);
    6160    GRefPtr<GMenu> buildMenu(const Vector<WebContextMenuItemGlib>&);
    62     void populate(const Vector<RefPtr<WebContextMenuItem>>&);
     61    void populate(const Vector<Ref<WebContextMenuItem>>&);
    6362    static void menuPositionFunction(GtkMenu*, gint*, gint*, gboolean*, WebContextMenuProxyGtk*);
    6463
    … …  
    7473
    7574#endif // ENABLE(CONTEXT_MENUS)
    76 #endif // WebContextMenuProxyGtk_h

  • trunk/Source/WebKit/UIProcess/ios/PageClientImplIOS.h

    r224930 r226323  
    9595#endif
    9696    RefPtr<WebPopupMenuProxy> createPopupMenuProxy(WebPageProxy&) override;
    97 #if ENABLE(CONTEXT_MENUS)
    98     RefPtr<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, const ContextMenuContextData&, const UserData&) override;
    99 #endif
    10097    Ref<WebCore::ValidationBubble> createValidationBubble(const String& message, const WebCore::ValidationBubble::Settings&) final;
    10198

  • trunk/Source/WebKit/UIProcess/ios/PageClientImplIOS.mm

    r225264 r226323  
    449449}
    450450
    451 #if ENABLE(CONTEXT_MENUS)
    452 RefPtr<WebContextMenuProxy> PageClientImpl::createContextMenuProxy(WebPageProxy&, const UserData&)
    453 {
    454     return nullptr;
    455 }
    456 #endif
    457 
    458451void PageClientImpl::setTextIndicator(Ref<TextIndicator> textIndicator, TextIndicatorWindowLifetime)
    459452{

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

    r226312 r226323  
    124124    RefPtr<WebPopupMenuProxy> createPopupMenuProxy(WebPageProxy&) override;
    125125#if ENABLE(CONTEXT_MENUS)
    126     RefPtr<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, const ContextMenuContextData&, const UserData&) override;
     126    Ref<WebContextMenuProxy> createContextMenuProxy(WebPageProxy&, ContextMenuContextData&&, const UserData&) override;
    127127#endif
    128128

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

    r226312 r226323  
    442442
    443443#if ENABLE(CONTEXT_MENUS)
    444 RefPtr<WebContextMenuProxy> PageClientImpl::createContextMenuProxy(WebPageProxy& page, const ContextMenuContextData& context, const UserData& userData)
    445 {
    446     return WebContextMenuProxyMac::create(m_view, page, context, userData);
     444Ref<WebContextMenuProxy> PageClientImpl::createContextMenuProxy(WebPageProxy& page, ContextMenuContextData&& context, const UserData& userData)
     445{
     446    return WebContextMenuProxyMac::create(m_view, page, WTFMove(context), userData);
    447447}
    448448#endif

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

    r217552 r226323  
    4848class WebContextMenuProxyMac : public WebContextMenuProxy {
    4949public:
    50     static auto create(NSView* view, WebPageProxy& page, const ContextMenuContextData& context, const UserData& userData)
     50    static auto create(NSView* view, WebPageProxy& page, ContextMenuContextData&& context, const UserData& userData)
    5151    {
    52         return adoptRef(*new WebContextMenuProxyMac(view, page, context, userData));
     52        return adoptRef(*new WebContextMenuProxyMac(view, page, WTFMove(context), userData));
    5353    }
    5454    ~WebContextMenuProxyMac();
    5555
    5656    void contextMenuItemSelected(const WebContextMenuItemData&);
    57     void showContextMenuWithItems(const Vector<WebContextMenuItemData>&) override;
     57    void showContextMenuWithItems(Vector<WebContextMenuItemData>&&) override;
    5858
    5959#if ENABLE(SERVICE_CONTROLS)
    … …  
    6565
    6666private:
    67     WebContextMenuProxyMac(NSView*, WebPageProxy&, const ContextMenuContextData&, const UserData&);
     67    WebContextMenuProxyMac(NSView*, WebPageProxy&, ContextMenuContextData&&, const UserData&);
    6868    void show() override;
    6969

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

    r226277 r226323  
    153153namespace WebKit {
    154154
    155 WebContextMenuProxyMac::WebContextMenuProxyMac(NSView* webView, WebPageProxy& page, const ContextMenuContextData& context, const UserData& userData)
    156     : WebContextMenuProxy(context, userData)
     155WebContextMenuProxyMac::WebContextMenuProxyMac(NSView* webView, WebPageProxy& page, ContextMenuContextData&& context, const UserData& userData)
     156    : WebContextMenuProxy(WTFMove(context), userData)
    157157    , m_webView(webView)
    158158    , m_page(page)
    … …  
    452452}
    453453
    454 void WebContextMenuProxyMac::showContextMenuWithItems(const Vector<WebContextMenuItemData>& items)
     454void WebContextMenuProxyMac::showContextMenuWithItems(Vector<WebContextMenuItemData>&& items)
    455455{
    456456    auto menu = createContextMenuFromItems(items);
    … …  
    470470void WebContextMenuProxyMac::showContextMenu()
    471471{
    472     Vector<RefPtr<WebContextMenuItem>> proposedAPIItems;
     472    Vector<Ref<WebContextMenuItem>> proposedAPIItems;
    473473    for (auto& item : m_context.menuItems())
    474474        proposedAPIItems.append(WebContextMenuItem::create(item));
    475475
    476     Vector<RefPtr<WebContextMenuItem>> clientItems;
     476    Vector<Ref<WebContextMenuItem>> clientItems;
    477477    bool useProposedItems = true;
    478478
    … …  
    501501        return;
    502502
    503     showContextMenuWithItems(items);
     503    showContextMenuWithItems(WTFMove(items));
    504504}
    505505
Note: See TracChangeset for help on using the changeset viewer.