Changeset 229390 in webkit


Ignore:
Timestamp:
Mar 7, 2018 6:06:39 PM (6 years ago)
Author:
youenn@apple.com
Message:

Match unsupported plugins based on domains and not origin
​https://bugs.webkit.org/show_bug.cgi?id=183384

Reviewed by Chris Dumez.

Source/WebCore:

Move from an origin-keyed map to a vector of plugins.
We iterate through the vector and a match happens if the page host name ends with the provided matching domain.
This allows supporting rules for *.mydomain.com by passing 'mydomain.com'.
Covered by existing tests.
We are not testing subdomains like www.localhost since there is no support in our CI but this is tested through Unit tests.

  • loader/EmptyClients.cpp:
  • platform/URL.cpp:

(WebCore::URL::isMatchingDomain const):

  • platform/URL.h:
  • plugins/PluginData.h:

(WebCore::isSupportedPlugin):
(WebCore::SupportedPluginName::decode):
(WebCore::SupportedPluginName::encode const):

  • plugins/PluginInfoProvider.h:

Source/WebKit:

Moved from a HashMap of plugins to a Vector of plugins since we cannot match exactly based on the origin.

  • Scripts/webkit/messages.py:
  • UIProcess/API/C/WKContext.cpp:

(WKContextAddSupportedPlugin):

  • UIProcess/API/Cocoa/WKProcessPool.mm:

(-[WKProcessPool _addSupportedPlugin:named:withMimeTypes:withExtensions:]):

  • UIProcess/Plugins/PluginInfoStore.cpp:

(WebKit::PluginInfoStore::isSupportedPlugin):
(WebKit::PluginInfoStore::supportedPluginNames):
(WebKit::PluginInfoStore::addSupportedPlugin):

  • UIProcess/Plugins/PluginInfoStore.h:
  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::addSupportedPlugin):

  • UIProcess/WebProcessPool.h:
  • UIProcess/WebProcessProxy.cpp:

(WebKit::WebProcessProxy::getPlugins):

  • UIProcess/WebProcessProxy.h:
  • UIProcess/WebProcessProxy.messages.in:
  • WebProcess/Plugins/WebPluginInfoProvider.cpp:

(WebKit::WebPluginInfoProvider::getPluginInfo):
(WebKit::WebPluginInfoProvider::getWebVisiblePluginInfo):

  • WebProcess/Plugins/WebPluginInfoProvider.h:

Source/WebKitLegacy/mac:

  • WebCoreSupport/WebPluginInfoProvider.h:
  • WebCoreSupport/WebPluginInfoProvider.mm:

(WebPluginInfoProvider::getPluginInfo):
(WebPluginInfoProvider::getWebVisiblePluginInfo):

Tools:

  • TestWebKitAPI/Tests/WebCore/URL.cpp:

(TestWebKitAPI::TEST_F):

  • WebKitTestRunner/TestController.cpp:

(WTR::TestController::setPluginSupportedMode): Update to whitelist
localhost and not ​http://localhost:8080

Location:
trunk
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r229378 r229390  
     12018-03-07  Youenn Fablet  <youenn@apple.com>
     2
     3        Match unsupported plugins based on domains and not origin
     4        https://bugs.webkit.org/show_bug.cgi?id=183384
     5
     6        Reviewed by Chris Dumez.
     7
     8        Move from an origin-keyed map to a vector of plugins.
     9        We iterate through the vector and a match happens if the page host name ends with the provided matching domain.
     10        This allows supporting rules for *.mydomain.com by passing 'mydomain.com'.
     11        Covered by existing tests.
     12        We are not testing subdomains like www.localhost since there is no support in our CI but this is tested through Unit tests.
     13
     14        * loader/EmptyClients.cpp:
     15        * platform/URL.cpp:
     16        (WebCore::URL::isMatchingDomain const):
     17        * platform/URL.h:
     18        * plugins/PluginData.h:
     19        (WebCore::isSupportedPlugin):
     20        (WebCore::SupportedPluginName::decode):
     21        (WebCore::SupportedPluginName::encode const):
     22        * plugins/PluginInfoProvider.h:
     23
    1242017-12-18  Youenn Fablet  <youenn@apple.com>
    225

  • trunk/Source/WebCore/loader/EmptyClients.cpp

    r228587 r229390  
    326326class EmptyPluginInfoProvider final : public PluginInfoProvider {
    327327    void refreshPlugins() final { };
    328     void getPluginInfo(Page&, Vector<PluginInfo>&, std::optional<SupportedPluginNames>&) final { }
     328    void getPluginInfo(Page&, Vector<PluginInfo>&, std::optional<Vector<SupportedPluginName>>&) final { }
    329329    void getWebVisiblePluginInfo(Page&, Vector<PluginInfo>&) final { }
    330330};

  • trunk/Source/WebCore/platform/URL.cpp

    r228323 r229390  
    775775
    776776    return true;
     777}
     778
     779bool URL::isMatchingDomain(const String& domain) const
     780{
     781    // We restrict it to HTTP for simplicity since we do not want to match data, blob or file based URLs.
     782    if (isNull() || !protocolIsInHTTPFamily())
     783        return false;
     784
     785    if (domain.isEmpty())
     786        return true;
     787
     788    auto host = this->host();
     789    if (!host.endsWith(domain))
     790        return false;
     791
     792    return host.length() == domain.length() || host.characterAt(host.length() - domain.length() - 1) == '.';
    777793}
    778794

  • trunk/Source/WebCore/platform/URL.h

    r228483 r229390  
    142142    bool cannotBeABaseURL() const { return m_cannotBeABaseURL; }
    143143
     144    WEBCORE_EXPORT bool isMatchingDomain(const String&) const;
     145
    144146    WEBCORE_EXPORT bool setProtocol(const String&);
    145147    void setHost(const String&);

  • trunk/Source/WebCore/plugins/PluginData.h

    r228587 r229390  
    2121#pragma once
    2222
    23 #include "SecurityOriginData.h"
     23#include "URL.h"
    2424#include <wtf/HashMap.h>
    2525#include <wtf/HashSet.h>
    … …  
    8989}
    9090
    91 struct SupportedPluginNames {
    92     HashSet<String> allOriginPlugins;
    93     HashMap<SecurityOriginData, HashSet<String>> originSpecificPlugins;
     91struct SupportedPluginName {
     92    String matchingDomain;
     93    String pluginName;
    9494
    9595    template<class Encoder> void encode(Encoder&) const;
    96     template<class Decoder> static std::optional<SupportedPluginNames> decode(Decoder&);
     96    template<class Decoder> static std::optional<SupportedPluginName> decode(Decoder&);
    9797};
    9898
    … …  
    127127    Page& m_page;
    128128    Vector<PluginInfo> m_plugins;
    129     std::optional<SupportedPluginNames> m_supportedPluginNames;
     129    std::optional<Vector<SupportedPluginName>> m_supportedPluginNames;
    130130};
    131131
    132 inline bool isSupportedPlugin(SupportedPluginNames& pluginNames, SecurityOriginData& origin, const String& pluginName)
     132inline bool isSupportedPlugin(const Vector<SupportedPluginName>& pluginNames, const URL& pageURL, const String& pluginName)
    133133{
    134     auto iterator = pluginNames.originSpecificPlugins.find(origin);
    135     if (iterator != pluginNames.originSpecificPlugins.end()) {
    136         if (iterator->value.contains(pluginName))
    137             return true;
    138     }
    139 
    140     return pluginNames.allOriginPlugins.contains(pluginName);
     134    return pluginNames.findMatching([&] (auto&& plugin) {
     135        return pageURL.isMatchingDomain(plugin.matchingDomain) && plugin.pluginName == pluginName;
     136    }) != notFound;
    141137}
    142138
    143 template<class Decoder> inline std::optional<SupportedPluginNames> SupportedPluginNames::decode(Decoder& decoder)
     139template<class Decoder> inline std::optional<SupportedPluginName> SupportedPluginName::decode(Decoder& decoder)
    144140{
    145     std::optional<HashSet<String>> allOriginPlugins;
    146     decoder >> allOriginPlugins;
    147     if (!allOriginPlugins)
     141    std::optional<String> matchingDomain;
     142    decoder >> matchingDomain;
     143    if (!matchingDomain)
    148144        return std::nullopt;
    149145
    150     std::optional<HashMap<SecurityOriginData, HashSet<String>>> originSpecificPlugins;
    151     decoder >> originSpecificPlugins;
    152     if (!originSpecificPlugins)
     146    std::optional<String> pluginName;
     147    decoder >> pluginName;
     148    if (!pluginName)
    153149        return std::nullopt;
    154150
    155     return SupportedPluginNames { WTFMove(allOriginPlugins.value()), WTFMove(originSpecificPlugins.value()) };
     151    return SupportedPluginName { WTFMove(matchingDomain.value()), WTFMove(pluginName.value()) };
    156152}
    157153
    158 template<class Encoder> inline void SupportedPluginNames::encode(Encoder& encoder) const
     154template<class Encoder> inline void SupportedPluginName::encode(Encoder& encoder) const
    159155{
    160     encoder << allOriginPlugins;
    161     encoder << originSpecificPlugins;
     156    encoder << matchingDomain;
     157    encoder << pluginName;
    162158}
    163159

  • trunk/Source/WebCore/plugins/PluginInfoProvider.h

    r228587 r229390  
    4040    void removePage(Page&);
    4141
    42     virtual void getPluginInfo(Page&, Vector<PluginInfo>&, std::optional<SupportedPluginNames>&) = 0;
     42    virtual void getPluginInfo(Page&, Vector<PluginInfo>&, std::optional<Vector<SupportedPluginName>>&) = 0;
    4343    virtual void getWebVisiblePluginInfo(Page&, Vector<PluginInfo>&) = 0;
    4444

  • trunk/Source/WebKit/ChangeLog

    r229386 r229390  
     12018-03-07  Youenn Fablet  <youenn@apple.com>
     2
     3        Match unsupported plugins based on domains and not origin
     4        https://bugs.webkit.org/show_bug.cgi?id=183384
     5
     6        Reviewed by Chris Dumez.
     7
     8        Moved from a HashMap of plugins to a Vector of plugins since we cannot match exactly based on the origin.
     9
     10        * Scripts/webkit/messages.py:
     11        * UIProcess/API/C/WKContext.cpp:
     12        (WKContextAddSupportedPlugin):
     13        * UIProcess/API/Cocoa/WKProcessPool.mm:
     14        (-[WKProcessPool _addSupportedPlugin:named:withMimeTypes:withExtensions:]):
     15        * UIProcess/Plugins/PluginInfoStore.cpp:
     16        (WebKit::PluginInfoStore::isSupportedPlugin):
     17        (WebKit::PluginInfoStore::supportedPluginNames):
     18        (WebKit::PluginInfoStore::addSupportedPlugin):
     19        * UIProcess/Plugins/PluginInfoStore.h:
     20        * UIProcess/WebProcessPool.cpp:
     21        (WebKit::WebProcessPool::addSupportedPlugin):
     22        * UIProcess/WebProcessPool.h:
     23        * UIProcess/WebProcessProxy.cpp:
     24        (WebKit::WebProcessProxy::getPlugins):
     25        * UIProcess/WebProcessProxy.h:
     26        * UIProcess/WebProcessProxy.messages.in:
     27        * WebProcess/Plugins/WebPluginInfoProvider.cpp:
     28        (WebKit::WebPluginInfoProvider::getPluginInfo):
     29        (WebKit::WebPluginInfoProvider::getWebVisiblePluginInfo):
     30        * WebProcess/Plugins/WebPluginInfoProvider.h:
     31
    1322018-03-07  Brent Fulgham  <bfulgham@apple.com>
    233

  • trunk/Source/WebKit/Scripts/webkit/messages.py

    r228587 r229390  
    399399        'WebCore::ShouldNotifyWhenResolved': ['<WebCore/ServiceWorkerTypes.h>'],
    400400        'WebCore::ShouldSample': ['<WebCore/DiagnosticLoggingClient.h>'],
    401         'WebCore::SupportedPluginNames': ['<WebCore/PluginData.h>'],
     401        'WebCore::SupportedPluginName': ['<WebCore/PluginData.h>'],
    402402        'WebCore::TextCheckingRequestData': ['<WebCore/TextChecking.h>'],
    403403        'WebCore::TextCheckingResult': ['<WebCore/TextCheckerClient.h>'],

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

    r228942 r229390  
    622622}
    623623
    624 void WKContextAddSupportedPlugin(WKContextRef contextRef, WKStringRef originRef, WKStringRef nameRef, WKArrayRef mimeTypesRef, WKArrayRef extensionsRef)
     624void WKContextAddSupportedPlugin(WKContextRef contextRef, WKStringRef domainRef, WKStringRef nameRef, WKArrayRef mimeTypesRef, WKArrayRef extensionsRef)
    625625{
    626626#if ENABLE(NETSCAPE_PLUGIN_API)
    … …  
    635635        extensions.add(toWTFString(static_cast<WKStringRef>(WKArrayGetItemAtIndex(extensionsRef, i))));
    636636
    637     RefPtr<SecurityOrigin> origin;
    638     if (!WKStringIsEmpty(originRef))
    639         origin = SecurityOrigin::createFromString(toWTFString(originRef));
    640     toImpl(contextRef)->addSupportedPlugin(origin.get(), toWTFString(nameRef), WTFMove(mimeTypes), WTFMove(extensions));
     637    toImpl(contextRef)->addSupportedPlugin(toWTFString(domainRef), toWTFString(nameRef), WTFMove(mimeTypes), WTFMove(extensions));
    641638#endif
    642639}

  • trunk/Source/WebKit/UIProcess/API/C/WKContextPrivate.h

    r228587 r229390  
    113113WK_EXPORT WKProcessID WKContextGetDatabaseProcessIdentifier(WKContextRef context);
    114114
    115 WK_EXPORT void WKContextAddSupportedPlugin(WKContextRef context, WKStringRef origin, WKStringRef name, WKArrayRef mimeTypes, WKArrayRef extensions);
     115WK_EXPORT void WKContextAddSupportedPlugin(WKContextRef context, WKStringRef domain, WKStringRef name, WKArrayRef mimeTypes, WKArrayRef extensions);
    116116WK_EXPORT void WKContextClearSupportedPlugins(WKContextRef context);
    117117

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKProcessPool.mm

    r228587 r229390  
    398398}
    399399
    400 - (void)_addSupportedPlugin:(NSString *) origin named:(NSString *) name withMimeTypes: (NSSet<NSString *> *) nsMimeTypes withExtensions: (NSSet<NSString *> *) nsExtensions
     400- (void)_addSupportedPlugin:(NSString *) domain named:(NSString *) name withMimeTypes: (NSSet<NSString *> *) nsMimeTypes withExtensions: (NSSet<NSString *> *) nsExtensions
    401401{
    402402    HashSet<String> mimeTypes;
    … …  
    407407        extensions.add(extension);
    408408
    409     _processPool->addSupportedPlugin([origin length] ? WebCore::SecurityOrigin::createFromString(origin).ptr() : nullptr, name, WTFMove(mimeTypes), WTFMove(extensions));
     409    _processPool->addSupportedPlugin(domain, name, WTFMove(mimeTypes), WTFMove(extensions));
    410410}
    411411

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKProcessPoolPrivate.h

    r228587 r229390  
    7373- (void)_setAutomationSession:(_WKAutomationSession *)automationSession WK_API_AVAILABLE(macosx(10.12), ios(10.0));
    7474
    75 - (void)_addSupportedPlugin:(NSString *) origin named:(NSString *) name withMimeTypes: (NSSet<NSString *> *) mimeTypes withExtensions: (NSSet<NSString *> *) extensions WK_API_AVAILABLE(macosx(WK_MAC_TBA), ios(WK_IOS_TBA));
     75- (void)_addSupportedPlugin:(NSString *) domain named:(NSString *) name withMimeTypes: (NSSet<NSString *> *) mimeTypes withExtensions: (NSSet<NSString *> *) extensions WK_API_AVAILABLE(macosx(WK_MAC_TBA), ios(WK_IOS_TBA));
    7676- (void)_clearSupportedPlugins WK_API_AVAILABLE(macosx(WK_MAC_TBA), ios(WK_IOS_TBA));
    7777

  • trunk/Source/WebKit/UIProcess/Plugins/PluginInfoStore.cpp

    r228587 r229390  
    3030
    3131#include "PluginModuleInfo.h"
     32#include <WebCore/MIMETypeRegistry.h>
     33#include <WebCore/SecurityOrigin.h>
    3234#include <WebCore/URL.h>
    33 #include <WebCore/MIMETypeRegistry.h>
    3435#include <algorithm>
    3536#include <wtf/ListHashSet.h>
    … …  
    215216bool PluginInfoStore::isSupportedPlugin(const String& mimeType, const URL& pluginURL, const String&, const URL& pageURL)
    216217{
    217     // We check only pageURLString for consistency with WebProcess visible plugins.
     218    // We check only pageURL for consistency with WebProcess visible plugins.
    218219    if (!m_supportedPlugins)
    219220        return true;
    220221
    221     for (auto& plugin : m_supportedPlugins->originSpecificPlugins.get(SecurityOriginData { pageURL.protocol().toString(), pageURL.host(), pageURL.port() })) {
    222         if (isSupportedPlugin(plugin, mimeType, pluginURL))
    223             return true;
    224     }
    225     for (auto& plugin : m_supportedPlugins->allOriginPlugins) {
    226         if (isSupportedPlugin(plugin, mimeType, pluginURL))
    227             return true;
    228     }
    229     return false;
    230 }
    231 
    232 std::optional<SupportedPluginNames> PluginInfoStore::supportedPluginNames()
     222    return m_supportedPlugins->findMatching([&] (auto&& plugin) {
     223        return pageURL.isMatchingDomain(plugin.matchingDomain) && isSupportedPlugin(plugin, mimeType, pluginURL);
     224    }) != notFound;
     225}
     226
     227std::optional<Vector<SupportedPluginName>> PluginInfoStore::supportedPluginNames()
    233228{
    234229    if (!m_supportedPlugins)
    235230        return std::nullopt;
    236231
    237     HashSet<String> allOriginPlugins;
    238     for (auto& plugin : m_supportedPlugins->allOriginPlugins)
    239         allOriginPlugins.add(plugin.name);
    240 
    241     HashMap<SecurityOriginData, HashSet<String>> originSpecificPlugins;
    242     for (auto& keyValue : m_supportedPlugins->originSpecificPlugins) {
    243         HashSet<String> names;
    244         for (auto& plugin : keyValue.value)
    245             names.add(plugin.name);
    246         originSpecificPlugins.add(keyValue.key, WTFMove(names));
    247     }
    248     return SupportedPluginNames { WTFMove(allOriginPlugins), WTFMove(originSpecificPlugins) };
    249 }
    250 
    251 void PluginInfoStore::addSupportedPlugin(const SecurityOrigin* origin, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions)
     232    return WTF::map(*m_supportedPlugins, [] (auto&& item) {
     233        return SupportedPluginName { item.matchingDomain, item.name };
     234    });
     235}
     236
     237void PluginInfoStore::addSupportedPlugin(String&& domainName, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions)
    252238{
    253239    if (!m_supportedPlugins)
    254         m_supportedPlugins = SupportedPlugins { };
    255 
    256     SupportedPlugin plugin { WTFMove(name), WTFMove(mimeTypes), WTFMove(extensions) };
    257     if (!origin) {
    258         m_supportedPlugins->allOriginPlugins.append(WTFMove(plugin));
    259         return;
    260     }
    261     m_supportedPlugins->originSpecificPlugins.ensure(SecurityOriginData::fromSecurityOrigin(*origin), [] {
    262         return Vector<SupportedPlugin> { };
    263     }).iterator->value.append(WTFMove(plugin));
     240        m_supportedPlugins = Vector<SupportedPlugin> { };
     241
     242    m_supportedPlugins->append(SupportedPlugin { WTFMove(domainName), WTFMove(name), WTFMove(mimeTypes), WTFMove(extensions) });
    264243}
    265244

  • trunk/Source/WebKit/UIProcess/Plugins/PluginInfoStore.h

    r228587 r229390  
    6565
    6666    bool isSupportedPlugin(const String& mimeType, const WebCore::URL& pluginURL, const String& frameURLString, const WebCore::URL& pageURL);
    67     std::optional<WebCore::SupportedPluginNames> supportedPluginNames();
    68     void addSupportedPlugin(const WebCore::SecurityOrigin*, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions);
     67    std::optional<Vector<WebCore::SupportedPluginName>> supportedPluginNames();
     68    void addSupportedPlugin(String&& matchingDomain, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions);
    6969    void clearSupportedPlugins() { m_supportedPlugins = std::nullopt; }
    7070
    … …  
    9898
    9999    struct SupportedPlugin {
     100        String matchingDomain;
    100101        String name;
    101102        HashSet<String> mimeTypes;
    102103        HashSet<String> extensions;
    103104    };
    104     struct SupportedPlugins {
    105         Vector<SupportedPlugin> allOriginPlugins;
    106         HashMap<WebCore::SecurityOriginData, Vector<SupportedPlugin>> originSpecificPlugins;
    107     };
    108105    static bool isSupportedPlugin(const SupportedPlugin&, const String& mimeType, const WebCore::URL& pluginURL);
    109106
    110     std::optional<SupportedPlugins> m_supportedPlugins;
     107    std::optional<Vector<SupportedPlugin>> m_supportedPlugins;
    111108};
    112109   

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

    r228942 r229390  
    17941794#endif
    17951795
    1796 void WebProcessPool::addSupportedPlugin(SecurityOrigin* origin, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions)
     1796void WebProcessPool::addSupportedPlugin(String&& matchingDomain, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions)
    17971797{
    17981798#if ENABLE(NETSCAPE_PLUGIN_API)
    1799     m_pluginInfoStore.addSupportedPlugin(origin, WTFMove(name), WTFMove(mimeTypes), WTFMove(extensions));
     1799    m_pluginInfoStore.addSupportedPlugin(WTFMove(matchingDomain), WTFMove(name), WTFMove(mimeTypes), WTFMove(extensions));
    18001800#else
    1801     UNUSED_PARAM(origin);
     1801    UNUSED_PARAM(matchingDomain);
    18021802    UNUSED_PARAM(name);
    18031803    UNUSED_PARAM(mimeTypes);

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

    r229140 r229390  
    203203#endif
    204204
    205     void addSupportedPlugin(WebCore::SecurityOrigin*, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions);
     205    void addSupportedPlugin(String&& matchingDomain, String&& name, HashSet<String>&& mimeTypes, HashSet<String> extensions);
    206206    void clearSupportedPlugins();
    207207

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

    r229178 r229390  
    571571
    572572#if ENABLE(NETSCAPE_PLUGIN_API)
    573 void WebProcessProxy::getPlugins(bool refresh, Vector<PluginInfo>& plugins, Vector<PluginInfo>& applicationPlugins, std::optional<WebCore::SupportedPluginNames>& supportedPluginNames)
     573void WebProcessProxy::getPlugins(bool refresh, Vector<PluginInfo>& plugins, Vector<PluginInfo>& applicationPlugins, std::optional<Vector<WebCore::SupportedPluginName>>& supportedPluginNames)
    574574{
    575575    if (refresh)

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

    r229178 r229390  
    239239    // Plugins
    240240#if ENABLE(NETSCAPE_PLUGIN_API)
    241     void getPlugins(bool refresh, Vector<WebCore::PluginInfo>& plugins, Vector<WebCore::PluginInfo>& applicationPlugins, std::optional<WebCore::SupportedPluginNames>&);
     241    void getPlugins(bool refresh, Vector<WebCore::PluginInfo>& plugins, Vector<WebCore::PluginInfo>& applicationPlugins, std::optional<Vector<WebCore::SupportedPluginName>>&);
    242242#endif // ENABLE(NETSCAPE_PLUGIN_API)
    243243#if ENABLE(NETSCAPE_PLUGIN_API)

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.messages.in

    r228587 r229390  
    3434    # Plugin messages.
    3535#if ENABLE(NETSCAPE_PLUGIN_API)
    36     GetPlugins(bool refresh) -> (Vector<WebCore::PluginInfo> plugins, Vector<WebCore::PluginInfo> applicationPlugins, struct std::optional<WebCore::SupportedPluginNames> supportedPluginNames)
     36    GetPlugins(bool refresh) -> (Vector<WebCore::PluginInfo> plugins, Vector<WebCore::PluginInfo> applicationPlugins, struct std::optional<Vector<WebCore::SupportedPluginName>> supportedPluginNames)
    3737    GetPluginProcessConnection(uint64_t pluginProcessToken) -> (IPC::Attachment connectionHandle, bool supportsAsynchronousInitialization) Delayed
    3838#endif

  • trunk/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.cpp

    r228587 r229390  
    3636#include <WebCore/MainFrame.h>
    3737#include <WebCore/Page.h>
    38 #include <WebCore/SecurityOriginData.h>
    3938#include <WebCore/SubframeLoader.h>
    4039#include <wtf/text/StringHash.h>
    … …  
    9897}
    9998
    100 void WebPluginInfoProvider::getPluginInfo(Page& page, Vector<PluginInfo>& plugins, std::optional<SupportedPluginNames>& supportedPluginNames)
     99void WebPluginInfoProvider::getPluginInfo(Page& page, Vector<PluginInfo>& plugins, std::optional<Vector<SupportedPluginName>>& supportedPluginNames)
    101100{
    102101#if ENABLE(NETSCAPE_PLUGIN_API)
    … …  
    122121    ASSERT_ARG(plugins, plugins.isEmpty());
    123122
    124     std::optional<WebCore::SupportedPluginNames> supportedPluginNames;
     123    std::optional<Vector<WebCore::SupportedPluginName>> supportedPluginNames;
    125124    getPluginInfo(page, plugins, supportedPluginNames);
    126125
    127126    auto* document = page.mainFrame().document();
     127
     128    if (document && supportedPluginNames) {
     129        plugins.removeAllMatching([&] (auto& plugin) {
     130            return !isSupportedPlugin(*supportedPluginNames, document->url(), plugin.name);
     131        });
     132    }
     133
     134#if PLATFORM(MAC)
    128135    auto* origin = document ? &document->securityOrigin(): nullptr;
    129 
    130     if (origin && supportedPluginNames) {
    131         auto originData = SecurityOriginData::fromSecurityOrigin(*origin);
    132         plugins.removeAllMatching([&] (auto& plugin) {
    133             return !isSupportedPlugin(*supportedPluginNames, originData, plugin.name);
    134         });
    135     }
    136 
    137 #if PLATFORM(MAC)
    138136    if (origin && origin->isLocal())
    139137        return;

  • trunk/Source/WebKit/WebProcess/Plugins/WebPluginInfoProvider.h

    r228587 r229390  
    4646    WebPluginInfoProvider();
    4747
    48     void getPluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&, std::optional<WebCore::SupportedPluginNames>&) final;
     48    void getPluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&, std::optional<Vector<WebCore::SupportedPluginName>>&) final;
    4949    void getWebVisiblePluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&) final;
    5050    void refreshPlugins() override;
    … …  
    6969    Vector<WebCore::PluginInfo> m_cachedPlugins;
    7070    Vector<WebCore::PluginInfo> m_cachedApplicationPlugins;
    71     std::optional<WebCore::SupportedPluginNames> m_cachedSupportedPluginNames;
     71    std::optional<Vector<WebCore::SupportedPluginName>> m_cachedSupportedPluginNames;
    7272#endif
    7373};

  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r229297 r229390  
     12018-03-07  Youenn Fablet  <youenn@apple.com>
     2
     3        Match unsupported plugins based on domains and not origin
     4        https://bugs.webkit.org/show_bug.cgi?id=183384
     5
     6        Reviewed by Chris Dumez.
     7
     8        * WebCoreSupport/WebPluginInfoProvider.h:
     9        * WebCoreSupport/WebPluginInfoProvider.mm:
     10        (WebPluginInfoProvider::getPluginInfo):
     11        (WebPluginInfoProvider::getWebVisiblePluginInfo):
     12
    1132018-03-05  Andy Estes  <aestes@apple.com>
    214

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebPluginInfoProvider.h

    r228587 r229390  
    3535private:
    3636    void refreshPlugins() override;
    37     void getPluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&, std::optional<WebCore::SupportedPluginNames>&) final;
     37    void getPluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&, std::optional<Vector<WebCore::SupportedPluginName>>&) final;
    3838    void getWebVisiblePluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&) final;
    3939

  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebPluginInfoProvider.mm

    r228587 r229390  
    5656}
    5757
    58 void WebPluginInfoProvider::getPluginInfo(WebCore::Page& page, Vector<WebCore::PluginInfo>& plugins, std::optional<SupportedPluginNames>&)
     58void WebPluginInfoProvider::getPluginInfo(WebCore::Page& page, Vector<WebCore::PluginInfo>& plugins, std::optional<Vector<SupportedPluginName>>&)
    5959{
    6060    BEGIN_BLOCK_OBJC_EXCEPTIONS;
    … …  
    7272void WebPluginInfoProvider::getWebVisiblePluginInfo(WebCore::Page& page, Vector<WebCore::PluginInfo>& plugins)
    7373{
    74     std::optional<SupportedPluginNames> supportedPluginNames;
     74    std::optional<Vector<SupportedPluginName>> supportedPluginNames;
    7575    getPluginInfo(page, plugins, supportedPluginNames);
    7676}

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebPluginInfoProvider.cpp

    r228587 r229390  
    5050}
    5151
    52 void WebPluginInfoProvider::getPluginInfo(WebCore::Page& page, Vector<WebCore::PluginInfo>& outPlugins, std::optional<WebCore::SupportedPluginNames>&)
     52void WebPluginInfoProvider::getPluginInfo(WebCore::Page& page, Vector<WebCore::PluginInfo>& outPlugins, std::optional<Vector<WebCore::SupportedPluginName>>&)
    5353{
    5454    const Vector<PluginPackage*>& plugins = PluginDatabase::installedPlugins()->plugins();
    … …  
    8585void WebPluginInfoProvider::getWebVisiblePluginInfo(WebCore::Page& page, Vector<WebCore::PluginInfo>& plugins)
    8686{
    87     std::optional<WebCore::SupportedPluginNames> supportedPluginNames;
     87    std::optional<Vector<WebCore::SupportedPluginName>> supportedPluginNames;
    8888    getPluginInfo(page, plugins, supportedPluginNames);
    8989}

  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebPluginInfoProvider.h

    r228587 r229390  
    3737private:
    3838    void refreshPlugins() final;
    39     void getPluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&, std::optional<WebCore::SupportedPluginNames>&) final;
     39    void getPluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&, std::optional<Vector<WebCore::SupportedPluginName>>&) final;
    4040    void getWebVisiblePluginInfo(WebCore::Page&, Vector<WebCore::PluginInfo>&) final;
    4141#if PLATFORM(MAC)

  • trunk/Tools/ChangeLog

    r229381 r229390  
     12018-03-07  Youenn Fablet  <youenn@apple.com>
     2
     3        Match unsupported plugins based on domains and not origin
     4        https://bugs.webkit.org/show_bug.cgi?id=183384
     5
     6        Reviewed by Chris Dumez.
     7
     8        * TestWebKitAPI/Tests/WebCore/URL.cpp:
     9        (TestWebKitAPI::TEST_F):
     10        * WebKitTestRunner/TestController.cpp:
     11        (WTR::TestController::setPluginSupportedMode): Update to whitelist
     12        localhost and not http://localhost:8080
     13
    1142018-03-07  Jonathan Bedard  <jbedard@apple.com>
    215

  • trunk/Tools/TestWebKitAPI/Tests/WebCore/URL.cpp

    r228323 r229390  
    265265}
    266266
     267TEST_F(URLTest, HostIsMatchingDomain)
     268{
     269    URL url = createURL("http://www.webkit.org");
     270
     271    EXPECT_TRUE(url.isMatchingDomain(String { }));
     272    EXPECT_TRUE(url.isMatchingDomain(emptyString()));
     273    EXPECT_TRUE(url.isMatchingDomain(ASCIILiteral("org")));
     274    EXPECT_TRUE(url.isMatchingDomain(ASCIILiteral("webkit.org")));
     275    EXPECT_TRUE(url.isMatchingDomain(ASCIILiteral("www.webkit.org")));
     276
     277    EXPECT_FALSE(url.isMatchingDomain(ASCIILiteral("rg")));
     278    EXPECT_FALSE(url.isMatchingDomain(ASCIILiteral(".org")));
     279    EXPECT_FALSE(url.isMatchingDomain(ASCIILiteral("ww.webkit.org")));
     280    EXPECT_FALSE(url.isMatchingDomain(ASCIILiteral("http://www.webkit.org")));
     281
     282    url = createURL("file:///www.webkit.org");
     283
     284    EXPECT_FALSE(url.isMatchingDomain(String { }));
     285    EXPECT_FALSE(url.isMatchingDomain(emptyString()));
     286    EXPECT_FALSE(url.isMatchingDomain(ASCIILiteral("org")));
     287    EXPECT_FALSE(url.isMatchingDomain(ASCIILiteral("webkit.org")));
     288    EXPECT_FALSE(url.isMatchingDomain(ASCIILiteral("www.webkit.org")));
     289
     290    URL emptyURL;
     291    EXPECT_FALSE(emptyURL.isMatchingDomain(String { }));
     292    EXPECT_FALSE(emptyURL.isMatchingDomain(emptyString()));
     293}
     294
    267295} // namespace TestWebKitAPI

  • trunk/Tools/WebKitTestRunner/TestController.cpp

    r229349 r229390  
    17041704    WKRetainPtr<WKMutableArrayRef> emptyArray = adoptWK(WKMutableArrayCreate());
    17051705    WKRetainPtr<WKStringRef> allOrigins = adoptWK(WKStringCreateWithUTF8CString(""));
    1706     WKRetainPtr<WKStringRef> specificOrigin = adoptWK(WKStringCreateWithUTF8CString("http://localhost:8080"));
     1706    WKRetainPtr<WKStringRef> specificOrigin = adoptWK(WKStringCreateWithUTF8CString("localhost"));
    17071707
    17081708    WKRetainPtr<WKStringRef> pdfName = adoptWK(WKStringCreateWithUTF8CString("My personal PDF"));
Note: See TracChangeset for help on using the changeset viewer.