Changeset 244695 in webkit


Ignore:
Timestamp:
Apr 26, 2019 10:03:15 AM (5 years ago)
Author:
achristensen@apple.com
Message:

Add ENABLE(CONTENT_EXTENSIONS) and namespace ContentExtensions to ResourceLoadInfo.h
​https://bugs.webkit.org/show_bug.cgi?id=197165

Reviewed by Youenn Fablet.

Source/WebCore:

No change in behavior. This will just make it harder for people working on the loader to mistake
these ContentExtension specific structures for other structures general to loading.
One such mistake was made in r244248.

  • Modules/websockets/WebSocketChannel.cpp:

(WebCore::WebSocketChannel::connect):

  • contentextensions/ContentExtensionsBackend.h:
  • css/StyleSheetContents.cpp:

(WebCore::StyleSheetContents::subresourcesAllowReuse const):

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::loadResource):

  • loader/FrameLoader.cpp:

(WebCore::FrameLoader::loadResourceSynchronously):

  • loader/NetscapePlugInStreamLoader.cpp:

(WebCore::NetscapePlugInStreamLoader::NetscapePlugInStreamLoader):

  • loader/PingLoader.cpp:

(WebCore::processContentRuleListsForLoad):
(WebCore::PingLoader::loadImage):
(WebCore::PingLoader::sendPing):
(WebCore::PingLoader::sendViolationReport):

  • loader/ResourceLoadInfo.cpp:

(WebCore::toResourceType): Deleted.
(WebCore::readResourceType): Deleted.
(WebCore::readLoadType): Deleted.
(WebCore::ResourceLoadInfo::isThirdParty const): Deleted.
(WebCore::ResourceLoadInfo::getResourceFlags const): Deleted.

  • loader/ResourceLoadInfo.h:
  • loader/ResourceLoader.cpp:

(WebCore::ResourceLoader::willSendRequestInternal):

  • loader/ResourceLoader.h:
  • loader/SubresourceLoader.cpp:

(WebCore::SubresourceLoader::SubresourceLoader):

  • loader/cache/CachedResourceLoader.cpp:

(WebCore::CachedResourceLoader::requestResource):

  • page/DOMWindow.cpp:

(WebCore::DOMWindow::open):

  • page/UserContentProvider.cpp:

(WebCore::UserContentProvider::processContentRuleListsForLoad):
(WebCore::UserContentProvider::actionsForResourceLoad):

  • page/UserContentProvider.h:

Tools:

  • TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp:
Location:
trunk
Files:
21 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r244692 r244695  
     12019-04-26  Alex Christensen  <achristensen@webkit.org>
     2
     3        Add ENABLE(CONTENT_EXTENSIONS) and namespace ContentExtensions to ResourceLoadInfo.h
     4        https://bugs.webkit.org/show_bug.cgi?id=197165
     5
     6        Reviewed by Youenn Fablet.
     7
     8        No change in behavior.  This will just make it harder for people working on the loader to mistake
     9        these ContentExtension specific structures for other structures general to loading.
     10        One such mistake was made in r244248.
     11
     12        * Modules/websockets/WebSocketChannel.cpp:
     13        (WebCore::WebSocketChannel::connect):
     14        * contentextensions/ContentExtensionsBackend.h:
     15        * css/StyleSheetContents.cpp:
     16        (WebCore::StyleSheetContents::subresourcesAllowReuse const):
     17        * html/HTMLMediaElement.cpp:
     18        (WebCore::HTMLMediaElement::loadResource):
     19        * loader/FrameLoader.cpp:
     20        (WebCore::FrameLoader::loadResourceSynchronously):
     21        * loader/NetscapePlugInStreamLoader.cpp:
     22        (WebCore::NetscapePlugInStreamLoader::NetscapePlugInStreamLoader):
     23        * loader/PingLoader.cpp:
     24        (WebCore::processContentRuleListsForLoad):
     25        (WebCore::PingLoader::loadImage):
     26        (WebCore::PingLoader::sendPing):
     27        (WebCore::PingLoader::sendViolationReport):
     28        * loader/ResourceLoadInfo.cpp:
     29        (WebCore::toResourceType): Deleted.
     30        (WebCore::readResourceType): Deleted.
     31        (WebCore::readLoadType): Deleted.
     32        (WebCore::ResourceLoadInfo::isThirdParty const): Deleted.
     33        (WebCore::ResourceLoadInfo::getResourceFlags const): Deleted.
     34        * loader/ResourceLoadInfo.h:
     35        * loader/ResourceLoader.cpp:
     36        (WebCore::ResourceLoader::willSendRequestInternal):
     37        * loader/ResourceLoader.h:
     38        * loader/SubresourceLoader.cpp:
     39        (WebCore::SubresourceLoader::SubresourceLoader):
     40        * loader/cache/CachedResourceLoader.cpp:
     41        (WebCore::CachedResourceLoader::requestResource):
     42        * page/DOMWindow.cpp:
     43        (WebCore::DOMWindow::open):
     44        * page/UserContentProvider.cpp:
     45        (WebCore::UserContentProvider::processContentRuleListsForLoad):
     46        (WebCore::UserContentProvider::actionsForResourceLoad):
     47        * page/UserContentProvider.h:
     48
    1492019-04-26  Alex Christensen  <achristensen@webkit.org>
    250

  • trunk/Source/WebCore/Modules/websockets/WebSocketChannel.cpp

    r244391 r244695  
    9090    if (auto* page = m_document->page()) {
    9191        if (auto* documentLoader = m_document->loader()) {
    92             auto results = page->userContentProvider().processContentRuleListsForLoad(url, ResourceType::Raw, *documentLoader);
     92            auto results = page->userContentProvider().processContentRuleListsForLoad(url, ContentExtensions::ResourceType::Raw, *documentLoader);
    9393            if (results.summary.blockedLoad) {
    9494                Ref<WebSocketChannel> protectedThis(*this);

  • trunk/Source/WebCore/contentextensions/ContentExtensionsBackend.h

    r243319 r244695  
    3939class ResourceRequest;
    4040
    41 struct ResourceLoadInfo;
    42 
    4341namespace ContentExtensions {
    4442
    4543class CompiledContentExtension;
     44struct ResourceLoadInfo;
    4645
    4746// The ContentExtensionsBackend is the internal model of all the content extensions.

  • trunk/Source/WebCore/css/StyleSheetContents.cpp

    r243319 r244695  
    513513        if (page && documentLoader) {
    514514            const auto& request = resource.resourceRequest();
    515             auto results = page->userContentProvider().processContentRuleListsForLoad(request.url(), toResourceType(resource.type()), *documentLoader);
     515            auto results = page->userContentProvider().processContentRuleListsForLoad(request.url(), ContentExtensions::toResourceType(resource.type()), *documentLoader);
    516516            if (results.summary.blockedLoad || results.summary.madeHTTPS)
    517517                return true;

  • trunk/Source/WebCore/dom/ExtensionStyleSheets.cpp

    r239181 r244695  
    4848namespace WebCore {
    4949
     50#if ENABLE(CONTENT_EXTENSIONS)
    5051using namespace ContentExtensions;
     52#endif
    5153using namespace HTMLNames;
    5254

  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r244440 r244695  
    15221522#if ENABLE(CONTENT_EXTENSIONS)
    15231523    if (auto documentLoader = makeRefPtr(frame->loader().documentLoader())) {
    1524         if (page->userContentProvider().processContentRuleListsForLoad(url, ResourceType::Media, *documentLoader).summary.blockedLoad) {
     1524        if (page->userContentProvider().processContentRuleListsForLoad(url, ContentExtensions::ResourceType::Media, *documentLoader).summary.blockedLoad) {
    15251525            mediaLoadingFailed(MediaPlayer::FormatError);
    15261526            return;

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

    r244540 r244695  
    30703070        if (auto* page = m_frame.page()) {
    30713071            if (m_documentLoader) {
    3072                 auto results = page->userContentProvider().processContentRuleListsForLoad(newRequest.url(), ResourceType::Raw, *m_documentLoader);
     3072                auto results = page->userContentProvider().processContentRuleListsForLoad(newRequest.url(), ContentExtensions::ResourceType::Raw, *m_documentLoader);
    30733073                bool blockedLoad = results.summary.blockedLoad;
    30743074                ContentExtensions::applyResultsToRequest(WTFMove(results), page, newRequest);

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

    r233668 r244695  
    6161{
    6262#if ENABLE(CONTENT_EXTENSIONS)
    63     m_resourceType = ResourceType::PlugInStream;
     63    m_resourceType = ContentExtensions::ResourceType::PlugInStream;
    6464#endif
    6565}

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

    r243319 r244695  
    5858namespace WebCore {
    5959
    60 #if !ENABLE(CONTENT_EXTENSIONS)
     60#if ENABLE(CONTENT_EXTENSIONS)
    6161
    6262// Returns true if we should block the load.
    63 static inline bool processContentRuleListsForLoad(const Frame&, ResourceRequest&, ResourceType)
    64 {
    65     return false;
    66 }
    67 
    68 #else
    69 
    70 // Returns true if we should block the load.
    71 static bool processContentRuleListsForLoad(const Frame& frame, ResourceRequest& request, ResourceType resourceType)
     63static bool processContentRuleListsForLoad(const Frame& frame, ResourceRequest& request, ContentExtensions::ResourceType resourceType)
    7264{
    7365    auto* documentLoader = frame.loader().documentLoader();
    … …  
    9688
    9789    ResourceRequest request(url);
    98     if (processContentRuleListsForLoad(frame, request, ResourceType::Image))
    99         return;
     90#if ENABLE(CONTENT_EXTENSIONS)
     91    if (processContentRuleListsForLoad(frame, request, ContentExtensions::ResourceType::Image))
     92        return;
     93#endif
    10094
    10195    document.contentSecurityPolicy()->upgradeInsecureRequestIfNeeded(request, ContentSecurityPolicy::InsecureRequestType::Load);
    … …  
    122116
    123117    ResourceRequest request(pingURL);
    124     if (processContentRuleListsForLoad(frame, request, ResourceType::Raw))
    125         return;
     118#if ENABLE(CONTENT_EXTENSIONS)
     119    if (processContentRuleListsForLoad(frame, request, ContentExtensions::ResourceType::Raw))
     120        return;
     121#endif
    126122
    127123    auto& document = *frame.document();
    … …  
    157153
    158154    ResourceRequest request(reportURL);
    159     if (processContentRuleListsForLoad(frame, request, ResourceType::Raw))
    160         return;
     155#if ENABLE(CONTENT_EXTENSIONS)
     156    if (processContentRuleListsForLoad(frame, request, ContentExtensions::ResourceType::Raw))
     157        return;
     158#endif
    161159
    162160    auto& document = *frame.document();

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

    r244428 r244695  
    3030#include "SecurityOrigin.h"
    3131
     32#if ENABLE(CONTENT_EXTENSIONS)
     33
    3234namespace WebCore {
     35namespace ContentExtensions {
    3336
    3437ResourceType toResourceType(CachedResource::Type type)
    … …  
    128131}
    129132
     133} // namespace ContentExtensions
    130134} // namespace WebCore
     135
     136#endif // ENABLE(CONTENT_EXTENSIONS)

  • trunk/Source/WebCore/loader/ResourceLoadInfo.h

    r244428 r244695  
    2626#pragma once
    2727
     28#if ENABLE(CONTENT_EXTENSIONS)
     29
    2830#include "CachedResource.h"
    2931#include <wtf/URL.h>
    3032
    3133namespace WebCore {
     34namespace ContentExtensions {
    3235
    3336enum class ResourceType : uint16_t {
    … …  
    7881};
    7982
     83} // namespace ContentExtensions
    8084} // namespace WebCore
     85
     86#endif

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

    r244475 r244695  
    343343    ASSERT(!m_reachedTerminalState);
    344344#if ENABLE(CONTENT_EXTENSIONS)
    345     ASSERT(m_resourceType != ResourceType::Invalid);
     345    ASSERT(m_resourceType != ContentExtensions::ResourceType::Invalid);
    346346#endif
    347347

  • trunk/Source/WebCore/loader/ResourceLoader.h

    r243476 r244695  
    245245#if ENABLE(CONTENT_EXTENSIONS)
    246246protected:
    247     ResourceType m_resourceType { ResourceType::Invalid };
     247    ContentExtensions::ResourceType m_resourceType { ContentExtensions::ResourceType::Invalid };
    248248#endif
    249249};

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

    r243682 r244695  
    9999#endif
    100100#if ENABLE(CONTENT_EXTENSIONS)
    101     m_resourceType = toResourceType(resource.type());
     101    m_resourceType = ContentExtensions::toResourceType(resource.type());
    102102#endif
    103103    m_canCrossOriginRequestsAskUserForCredentials = resource.type() == CachedResource::Type::MainResource || frame.settings().allowCrossOriginSubresourcesToAskForCredentials();

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

    r244428 r244695  
    810810        const auto& resourceRequest = request.resourceRequest();
    811811        auto* page = frame()->page();
    812         auto results = page->userContentProvider().processContentRuleListsForLoad(resourceRequest.url(), toResourceType(type), *m_documentLoader);
     812        auto results = page->userContentProvider().processContentRuleListsForLoad(resourceRequest.url(), ContentExtensions::toResourceType(type), *m_documentLoader);
    813813        bool blockedLoad = results.summary.blockedLoad;
    814814        bool madeHTTPS = results.summary.madeHTTPS;

  • trunk/Source/WebCore/page/DOMWindow.cpp

    r244673 r244695  
    23672367        && firstFrame->mainFrame().document()
    23682368        && firstFrame->mainFrame().document()->loader()) {
    2369         auto results = firstFrame->page()->userContentProvider().processContentRuleListsForLoad(firstFrame->document()->completeURL(urlString), ResourceType::Popup, *firstFrame->mainFrame().document()->loader());
     2369        auto results = firstFrame->page()->userContentProvider().processContentRuleListsForLoad(firstFrame->document()->completeURL(urlString), ContentExtensions::ResourceType::Popup, *firstFrame->mainFrame().document()->loader());
    23702370        if (results.summary.blockedLoad)
    23712371            return RefPtr<WindowProxy> { nullptr };

  • trunk/Source/WebCore/page/UserContentProvider.cpp

    r243319 r244695  
    103103}
    104104   
    105 ContentRuleListResults UserContentProvider::processContentRuleListsForLoad(const URL& url, ResourceType resourceType, DocumentLoader& initiatingDocumentLoader)
     105ContentRuleListResults UserContentProvider::processContentRuleListsForLoad(const URL& url, ContentExtensions::ResourceType resourceType, DocumentLoader& initiatingDocumentLoader)
    106106{
    107107    if (!contentExtensionsEnabled(initiatingDocumentLoader))
    … …  
    111111}
    112112
    113 Vector<ContentExtensions::ActionsFromContentRuleList> UserContentProvider::actionsForResourceLoad(const ResourceLoadInfo& resourceLoadInfo, DocumentLoader& initiatingDocumentLoader)
     113Vector<ContentExtensions::ActionsFromContentRuleList> UserContentProvider::actionsForResourceLoad(const ContentExtensions::ResourceLoadInfo& resourceLoadInfo, DocumentLoader& initiatingDocumentLoader)
    114114{
    115115    if (!contentExtensionsEnabled(initiatingDocumentLoader))

  • trunk/Source/WebCore/page/UserContentProvider.h

    r243319 r244695  
    4747class UserStyleSheet;
    4848
    49 enum class ResourceType : uint16_t;
    50 
    51 struct ResourceLoadInfo;
    52 
     49#if ENABLE(CONTENT_EXTENSIONS)
    5350namespace ContentExtensions {
    5451class ContentExtensionsBackend;
    55 struct Action;
     52enum class ResourceType : uint16_t;
     53struct ResourceLoadInfo;
    5654}
     55#endif
    5756
    5857class UserContentProvider;
    … …  
    9089    // FIXME: These don't really belong here. They should probably bundled up in the ContentExtensionsBackend
    9190    // which should always exist.
    92     ContentRuleListResults processContentRuleListsForLoad(const URL&, ResourceType, DocumentLoader& initiatingDocumentLoader);
    93     Vector<ContentExtensions::ActionsFromContentRuleList> actionsForResourceLoad(const ResourceLoadInfo&, DocumentLoader& initiatingDocumentLoader);
     91    ContentRuleListResults processContentRuleListsForLoad(const URL&, ContentExtensions::ResourceType, DocumentLoader& initiatingDocumentLoader);
     92    Vector<ContentExtensions::ActionsFromContentRuleList> actionsForResourceLoad(const ContentExtensions::ResourceLoadInfo&, DocumentLoader& initiatingDocumentLoader);
    9493    WEBCORE_EXPORT void forEachContentExtension(const Function<void(const String&, ContentExtensions::ContentExtension&)>&, DocumentLoader& initiatingDocumentLoader);
    9594#endif

  • trunk/Source/WebCore/style/StyleScope.cpp

    r241018 r244695  
    5555namespace WebCore {
    5656
    57 using namespace ContentExtensions;
    5857using namespace HTMLNames;
    5958

  • trunk/Tools/ChangeLog

    r244693 r244695  
     12019-04-26  Alex Christensen  <achristensen@webkit.org>
     2
     3        Add ENABLE(CONTENT_EXTENSIONS) and namespace ContentExtensions to ResourceLoadInfo.h
     4        https://bugs.webkit.org/show_bug.cgi?id=197165
     5
     6        Reviewed by Youenn Fablet.
     7
     8        * TestWebKitAPI/Tests/WebCore/ContentExtensions.cpp:
     9
    1102019-04-26  Ryan Haddad  <ryanhaddad@apple.com>
    211

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

    r243319 r244695  
    6868}
    6969
     70namespace TestWebKitAPI {
    7071using namespace WebCore;
    71 
    72 namespace TestWebKitAPI {
     72using namespace WebCore::ContentExtensions;
    7373
    7474class ContentExtensionTest : public testing::Test {
Note: See TracChangeset for help on using the changeset viewer.