Changeset 254983 in webkit


Ignore:
Timestamp:
Jan 23, 2020, 10:50:55 AM (5 years ago)
Author:
achristensen@apple.com
Message:

ContentFilter should access DocumentLoader through an interface
https://bugs.webkit.org/show_bug.cgi?id=206564

Reviewed by Andy Estes.

This will make it easier to move, like to the NetworkProcess where there are no DocumentLoaders.
Also use WTF::Function instead of std::function and UniqueRef instead of std::unique_ptr.
No change in behavior.

  • WebCore.xcodeproj/project.pbxproj:
  • loader/ContentFilter.cpp:

(WebCore::ContentFilter::types):
(WebCore::ContentFilter::create):
(WebCore::ContentFilter::ContentFilter):
(WebCore::ContentFilter::continueAfterWillSendRequest):
(WebCore::ContentFilter::continueAfterResponseReceived):
(WebCore::ContentFilter::continueAfterDataReceived):
(WebCore::ContentFilter::continueAfterNotifyFinished):
(WebCore::ContentFilter::forEachContentFilterUntilBlocked):
(WebCore::ContentFilter::didDecide):
(WebCore::ContentFilter::deliverResourceData):
(WebCore::ContentFilter::handleProvisionalLoadFailure):
(): Deleted.

  • loader/ContentFilter.h:
  • loader/ContentFilterClient.h: Added.

(WebCore::ContentFilterClient::~ContentFilterClient):

  • loader/DocumentLoader.cpp:

(WebCore::DocumentLoader::handleProvisionalLoadFailure):
(WebCore::DocumentLoader::didBlock):

  • loader/DocumentLoader.h:
  • platform/cocoa/NetworkExtensionContentFilter.h:
  • platform/cocoa/NetworkExtensionContentFilter.mm:

(WebCore::NetworkExtensionContentFilter::create):

  • platform/cocoa/ParentalControlsContentFilter.h:
  • platform/cocoa/ParentalControlsContentFilter.mm:

(WebCore::ParentalControlsContentFilter::create):

Location:
trunk/Source/WebCore
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r254977 r254983  
     12020-01-23  Alex Christensen  <achristensen@webkit.org>
     2
     3        ContentFilter should access DocumentLoader through an interface
     4        https://bugs.webkit.org/show_bug.cgi?id=206564
     5
     6        Reviewed by Andy Estes.
     7
     8        This will make it easier to move, like to the NetworkProcess where there are no DocumentLoaders.
     9        Also use WTF::Function instead of std::function and UniqueRef instead of std::unique_ptr.
     10        No change in behavior.
     11
     12        * WebCore.xcodeproj/project.pbxproj:
     13        * loader/ContentFilter.cpp:
     14        (WebCore::ContentFilter::types):
     15        (WebCore::ContentFilter::create):
     16        (WebCore::ContentFilter::ContentFilter):
     17        (WebCore::ContentFilter::continueAfterWillSendRequest):
     18        (WebCore::ContentFilter::continueAfterResponseReceived):
     19        (WebCore::ContentFilter::continueAfterDataReceived):
     20        (WebCore::ContentFilter::continueAfterNotifyFinished):
     21        (WebCore::ContentFilter::forEachContentFilterUntilBlocked):
     22        (WebCore::ContentFilter::didDecide):
     23        (WebCore::ContentFilter::deliverResourceData):
     24        (WebCore::ContentFilter::handleProvisionalLoadFailure):
     25        (): Deleted.
     26        * loader/ContentFilter.h:
     27        * loader/ContentFilterClient.h: Added.
     28        (WebCore::ContentFilterClient::~ContentFilterClient):
     29        * loader/DocumentLoader.cpp:
     30        (WebCore::DocumentLoader::handleProvisionalLoadFailure):
     31        (WebCore::DocumentLoader::didBlock):
     32        * loader/DocumentLoader.h:
     33        * platform/cocoa/NetworkExtensionContentFilter.h:
     34        * platform/cocoa/NetworkExtensionContentFilter.mm:
     35        (WebCore::NetworkExtensionContentFilter::create):
     36        * platform/cocoa/ParentalControlsContentFilter.h:
     37        * platform/cocoa/ParentalControlsContentFilter.mm:
     38        (WebCore::ParentalControlsContentFilter::create):
     39
    1402020-01-23  Zalan Bujtas  <zalan@apple.com>
    241
  • trunk/Source/WebCore/Headers.cmake

    r254931 r254983  
    690690    loader/AdClickAttribution.h
    691691    loader/CanvasActivityRecord.h
     692    loader/ContentFilterClient.h
    692693    loader/CookieJar.h
    693694    loader/CrossOriginAccessControl.h
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r254931 r254983  
    19161916                5CD9F5671AA0F74200DA45FF /* DFABytecodeCompiler.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C39305F1AA0F6A90029C816 /* DFABytecodeCompiler.h */; settings = {ATTRIBUTES = (Private, ); }; };
    19171917                5CD9F5681AA0F74600DA45FF /* DFABytecodeInterpreter.h in Headers */ = {isa = PBXBuildFile; fileRef = 5C3930611AA0F6A90029C816 /* DFABytecodeInterpreter.h */; settings = {ATTRIBUTES = (Private, ); }; };
     1918                5CDCDDC623D80A1C00BA34A1 /* ContentFilterClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 5CDCDDBF23D7B7BE00BA34A1 /* ContentFilterClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
    19181919                5CDD83641E4325A000621E92 /* LibWebRTCDataChannelHandler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 5CDD833F1E43253D00621E92 /* LibWebRTCDataChannelHandler.cpp */; };
    19191920                5CDFA6C81AA4F2DA00EA8746 /* ContentExtensionActions.h in Headers */ = {isa = PBXBuildFile; fileRef = 5CDFA6C71AA4F2DA00EA8746 /* ContentExtensionActions.h */; settings = {ATTRIBUTES = (Private, ); }; };
     
    90699070                5CCC270622D53B6800964FA0 /* AutofillElements.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AutofillElements.h; sourceTree = "<group>"; };
    90709071                5CCC270722D53B6900964FA0 /* AutofillElements.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = AutofillElements.cpp; sourceTree = "<group>"; };
     9072                5CDCDDBF23D7B7BE00BA34A1 /* ContentFilterClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ContentFilterClient.h; sourceTree = "<group>"; };
    90719073                5CDD83391E4324BB00621E83 /* RealtimeIncomingVideoSourceCocoa.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = RealtimeIncomingVideoSourceCocoa.mm; sourceTree = "<group>"; };
    90729074                5CDD83391E4324BB00621E92 /* RealtimeIncomingVideoSource.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RealtimeIncomingVideoSource.cpp; sourceTree = "<group>"; };
     
    2575225754                                A149786C1ABAF33800CEF7E4 /* ContentFilter.cpp */,
    2575325755                                A149786D1ABAF33800CEF7E4 /* ContentFilter.h */,
     25756                                5CDCDDBF23D7B7BE00BA34A1 /* ContentFilterClient.h */,
    2575425757                                E1424C91164B52C800F32D40 /* CookieJar.cpp */,
    2575525758                                E1424C92164B52C800F32D40 /* CookieJar.h */,
     
    2943329436                                51FB67DC1AE6B82F00D06C5A /* ContentExtensionStyleSheet.h in Headers */,
    2943429437                                A149786F1ABAF33800CEF7E4 /* ContentFilter.h in Headers */,
     29438                                5CDCDDC623D80A1C00BA34A1 /* ContentFilterClient.h in Headers */,
    2943529439                                A14090FD1AA51E480091191A /* ContentFilterUnblockHandler.h in Headers */,
    2943629440                                5C9C2DB52241A67B00996B0B /* ContentRuleListResults.h in Headers */,
  • trunk/Source/WebCore/loader/ContentFilter.cpp

    r253519 r254983  
    3030
    3131#include "CachedRawResource.h"
     32#include "ContentFilterClient.h"
    3233#include "ContentFilterUnblockHandler.h"
    3334#include "DocumentLoader.h"
     
    5556{
    5657    static NeverDestroyed<Vector<ContentFilter::Type>> types {
    57         Vector<ContentFilter::Type> {
     58        Vector<ContentFilter::Type>::from(
    5859#if HAVE(PARENTAL_CONTROLS)
    5960            type<ParentalControlsContentFilter>(),
     
    6263            type<NetworkExtensionContentFilter>()
    6364#endif
    64         }
     65        )
    6566    };
    6667    return types;
    6768}
    6869
    69 std::unique_ptr<ContentFilter> ContentFilter::create(DocumentLoader& documentLoader)
     70std::unique_ptr<ContentFilter> ContentFilter::create(ContentFilterClient& client)
    7071{
    7172    Container filters;
    7273    for (auto& type : types()) {
    7374        auto filter = type.create();
    74         ASSERT(filter);
    7575        filters.append(WTFMove(filter));
    7676    }
     
    7979        return nullptr;
    8080
    81     return makeUnique<ContentFilter>(WTFMove(filters), documentLoader);
    82 }
    83 
    84 ContentFilter::ContentFilter(Container&& contentFilters, DocumentLoader& documentLoader)
    85     : m_contentFilters { WTFMove(contentFilters) }
    86     , m_documentLoader { documentLoader }
     81    return makeUnique<ContentFilter>(WTFMove(filters), client);
     82}
     83
     84ContentFilter::ContentFilter(Container&& contentFilters, ContentFilterClient& client)
     85    : m_contentFilters(WTFMove(contentFilters))
     86    , m_client(client)
    8787{
    8888    LOG(ContentFiltering, "Creating ContentFilter with %zu platform content filter(s).\n", m_contentFilters.size());
     
    9797bool ContentFilter::continueAfterWillSendRequest(ResourceRequest& request, const ResourceResponse& redirectResponse)
    9898{
    99     Ref<DocumentLoader> protectedDocumentLoader { m_documentLoader };
     99    Ref<ContentFilterClient> protectedClient { m_client };
    100100
    101101    LOG(ContentFiltering, "ContentFilter received request for <%s> with redirect response from <%s>.\n", request.url().string().ascii().data(), redirectResponse.url().string().ascii().data());
     
    136136bool ContentFilter::continueAfterResponseReceived(const ResourceResponse& response)
    137137{
    138     Ref<DocumentLoader> protectedDocumentLoader { m_documentLoader };
     138    Ref<ContentFilterClient> protectedClient { m_client };
    139139
    140140    if (m_state == State::Filtering) {
     
    150150bool ContentFilter::continueAfterDataReceived(const char* data, int length)
    151151{
    152     Ref<DocumentLoader> protectedDocumentLoader { m_documentLoader };
     152    Ref<ContentFilterClient> protectedClient { m_client };
    153153
    154154    if (m_state == State::Filtering) {
     
    169169{
    170170    ASSERT_UNUSED(resource, &resource == m_mainResource);
    171     Ref<DocumentLoader> protectedDocumentLoader { m_documentLoader };
     171    Ref<ContentFilterClient> protectedClient { m_client };
    172172
    173173    if (m_mainResource->errorOccurred())
     
    202202        }
    203203
    204         function(*contentFilter);
     204        function(contentFilter.get());
    205205
    206206        if (contentFilter->didBlockData()) {
    207207            ASSERT(!m_blockingContentFilter);
    208             m_blockingContentFilter = contentFilter.get();
     208            m_blockingContentFilter = &contentFilter;
    209209            didDecide(State::Blocked);
    210210            return;
     
    227227        return;
    228228
    229     ContentFilterUnblockHandler unblockHandler { m_blockingContentFilter->unblockHandler() };
    230     unblockHandler.setUnreachableURL(m_documentLoader.documentURL());
    231     auto frame { m_documentLoader.frame() };
    232     String unblockRequestDeniedScript { m_blockingContentFilter->unblockRequestDeniedScript() };
    233     if (!unblockRequestDeniedScript.isEmpty() && frame) {
    234         unblockHandler.wrapWithDecisionHandler([scriptController = makeWeakPtr(frame->script()), script = unblockRequestDeniedScript.isolatedCopy()](bool unblocked) {
    235             if (!unblocked && scriptController)
    236                 scriptController->executeScriptIgnoringException(script);
    237         });
    238     }
    239     m_documentLoader.frameLoader()->client().contentFilterDidBlockLoad(WTFMove(unblockHandler));
    240 
    241     m_blockedError = m_documentLoader.frameLoader()->blockedByContentFilterError(m_documentLoader.request());
    242     m_documentLoader.cancelMainResourceLoad(m_blockedError);
     229    m_blockedError = m_client.contentFilterDidBlock(m_blockingContentFilter->unblockHandler(), m_blockingContentFilter->unblockRequestDeniedScript());
     230    m_client.cancelMainResourceLoadForContentFilter(m_blockedError);
    243231}
    244232
     
    248236    ASSERT(resource.dataBufferingPolicy() == DataBufferingPolicy::BufferData);
    249237    if (auto* resourceBuffer = resource.resourceBuffer())
    250         m_documentLoader.dataReceived(resource, resourceBuffer->data(), resourceBuffer->size());
     238        m_client.dataReceivedThroughContentFilter(resourceBuffer->data(), resourceBuffer->size());
    251239}
    252240
     
    295283    SubstituteData substituteData { WTFMove(replacementData), error.failingURL(), response, SubstituteData::SessionHistoryVisibility::Hidden };
    296284    SetForScope<bool> loadingBlockedPage { m_isLoadingBlockedPage, true };
    297     m_documentLoader.frameLoader()->load(FrameLoadRequest(*m_documentLoader.frame(), blockedPageURL(), ShouldOpenExternalURLsPolicy::ShouldNotAllow, substituteData));
     285    m_client.handleProvisionalLoadFailureFromContentFilter(blockedPageURL(), substituteData);
    298286}
    299287
  • trunk/Source/WebCore/loader/ContentFilter.h

    r246190 r254983  
    3333#include <functional>
    3434#include <wtf/Forward.h>
     35#include <wtf/UniqueRef.h>
    3536
    3637namespace WebCore {
    3738
    3839class CachedRawResource;
     40class ContentFilterClient;
    3941class DocumentLoader;
    4042class ResourceRequest;
     
    4951    template <typename T> static void addType() { types().append(type<T>()); }
    5052
    51     static std::unique_ptr<ContentFilter> create(DocumentLoader&);
     53    static std::unique_ptr<ContentFilter> create(ContentFilterClient&);
    5254    ~ContentFilter();
    5355
     
    7072
    7173    struct Type {
    72         const std::function<std::unique_ptr<PlatformContentFilter>()> create;
     74        Function<UniqueRef<PlatformContentFilter>()> create;
    7375    };
    7476    template <typename T> static Type type();
    7577    WEBCORE_EXPORT static Vector<Type>& types();
    7678
    77     using Container = Vector<std::unique_ptr<PlatformContentFilter>>;
    78     friend std::unique_ptr<ContentFilter> std::make_unique<ContentFilter>(Container&&, DocumentLoader&);
    79     ContentFilter(Container&&, DocumentLoader&);
     79    using Container = Vector<UniqueRef<PlatformContentFilter>>;
     80    friend std::unique_ptr<ContentFilter> std::make_unique<ContentFilter>(Container&&, ContentFilterClient&);
     81    ContentFilter(Container&&, ContentFilterClient&);
    8082
    8183    template <typename Function> void forEachContentFilterUntilBlocked(Function&&);
     
    8385    void deliverResourceData(CachedResource&);
    8486
    85     const Container m_contentFilters;
    86     DocumentLoader& m_documentLoader;
     87    Container m_contentFilters;
     88    ContentFilterClient& m_client;
    8789    CachedResourceHandle<CachedRawResource> m_mainResource;
    88     PlatformContentFilter* m_blockingContentFilter { nullptr };
     90    const PlatformContentFilter* m_blockingContentFilter { nullptr };
    8991    State m_state { State::Stopped };
    9092    ResourceError m_blockedError;
  • trunk/Source/WebCore/loader/DocumentLoader.cpp

    r254857 r254983  
    103103#if ENABLE(CONTENT_FILTERING)
    104104#include "ContentFilter.h"
     105#include "FrameLoadRequest.h"
     106#include "ScriptController.h"
    105107#endif
    106108
     
    21872189}
    21882190
     2191#if ENABLE(CONTENT_FILTERING)
     2192void DocumentLoader::dataReceivedThroughContentFilter(const char* data, int size)
     2193{
     2194    dataReceived(data, size);
     2195}
     2196
     2197void DocumentLoader::cancelMainResourceLoadForContentFilter(const ResourceError& error)
     2198{
     2199    cancelMainResourceLoad(error);
     2200}
     2201
     2202void DocumentLoader::handleProvisionalLoadFailureFromContentFilter(const URL& blockedPageURL, SubstituteData& substituteData)
     2203{
     2204    frameLoader()->load(FrameLoadRequest(*frame(), blockedPageURL, ShouldOpenExternalURLsPolicy::ShouldNotAllow, substituteData));
     2205}
     2206
     2207ResourceError DocumentLoader::contentFilterDidBlock(ContentFilterUnblockHandler unblockHandler, WTF::String&& unblockRequestDeniedScript)
     2208{
     2209    unblockHandler.setUnreachableURL(documentURL());
     2210    if (!unblockRequestDeniedScript.isEmpty() && frame()) {
     2211        unblockHandler.wrapWithDecisionHandler([scriptController = makeWeakPtr(frame()->script()), script = unblockRequestDeniedScript.isolatedCopy()](bool unblocked) {
     2212            if (!unblocked && scriptController)
     2213                scriptController->executeScriptIgnoringException(script);
     2214        });
     2215    }
     2216    frameLoader()->client().contentFilterDidBlockLoad(WTFMove(unblockHandler));
     2217    return frameLoader()->blockedByContentFilterError(request());
     2218}
     2219#endif // ENABLE(CONTENT_FILTERING)
     2220
    21892221} // namespace WebCore
  • trunk/Source/WebCore/loader/DocumentLoader.h

    r254087 r254983  
    3232#include "CachedRawResourceClient.h"
    3333#include "CachedResourceHandle.h"
     34#include "ContentFilterClient.h"
    3435#include "ContentSecurityPolicyClient.h"
    3536#include "DeviceOrientationOrMotionPermissionState.h"
     
    143144    , public FrameDestructionObserver
    144145    , public ContentSecurityPolicyClient
     146#if ENABLE(CONTENT_FILTERING)
     147    , public ContentFilterClient
     148#endif
    145149    , private CachedRawResourceClient {
    146150    WTF_MAKE_FAST_ALLOCATED_WITH_HEAP_IDENTIFIER(DocumentLoader);
     
    367371
    368372#if ENABLE(CONTENT_FILTERING)
    369     ContentFilter* contentFilter() const;
     373    ContentFilter* contentFilter() const { return m_contentFilter.get(); }
     374    void ref() const final { RefCounted<DocumentLoader>::ref(); }
     375    void deref() const final { RefCounted<DocumentLoader>::deref(); }
    370376#endif
    371377
     
    445451
    446452    void responseReceived(const ResourceResponse&, CompletionHandler<void()>&&);
     453
     454#if ENABLE(CONTENT_FILTERING)
     455    // ContentFilterClient
     456    WEBCORE_EXPORT void dataReceivedThroughContentFilter(const char*, int) final;
     457    WEBCORE_EXPORT ResourceError contentFilterDidBlock(ContentFilterUnblockHandler, String&& unblockRequestDeniedScript) final;
     458    WEBCORE_EXPORT void cancelMainResourceLoadForContentFilter(const ResourceError&) final;
     459    WEBCORE_EXPORT void handleProvisionalLoadFailureFromContentFilter(const URL& blockedPageURL, SubstituteData&) final;
     460#endif
     461
    447462    void dataReceived(const char* data, int length);
    448463
     
    703718}
    704719
    705 #if ENABLE(CONTENT_FILTERING)
    706 
    707 inline ContentFilter* DocumentLoader::contentFilter() const
    708 {
    709     return m_contentFilter.get();
    710 }
    711 
    712 #endif
    713 
    714720inline void DocumentLoader::didTellClientAboutLoad(const String& url)
    715721{
  • trunk/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.h

    r253351 r254983  
    3131#include <wtf/OSObjectPtr.h>
    3232#include <wtf/RetainPtr.h>
     33#include <wtf/UniqueRef.h>
    3334
    3435enum NEFilterSourceStatus : NSInteger;
     
    4041
    4142class NetworkExtensionContentFilter final : public PlatformContentFilter {
    42     friend std::unique_ptr<NetworkExtensionContentFilter> std::make_unique<NetworkExtensionContentFilter>();
     43    friend UniqueRef<NetworkExtensionContentFilter> WTF::makeUniqueRefWithoutFastMallocCheck<NetworkExtensionContentFilter>();
    4344
    4445public:
    45     static std::unique_ptr<NetworkExtensionContentFilter> create();
     46    static UniqueRef<NetworkExtensionContentFilter> create();
    4647
    4748    void willSendRequest(ResourceRequest&, const ResourceResponse&) override;
  • trunk/Source/WebCore/platform/cocoa/NetworkExtensionContentFilter.mm

    r253351 r254983  
    7272}
    7373
    74 std::unique_ptr<NetworkExtensionContentFilter> NetworkExtensionContentFilter::create()
    75 {
    76     return makeUnique<NetworkExtensionContentFilter>();
     74UniqueRef<NetworkExtensionContentFilter> NetworkExtensionContentFilter::create()
     75{
     76    return makeUniqueRef<NetworkExtensionContentFilter>();
    7777}
    7878
  • trunk/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.h

    r253440 r254983  
    2929#include <wtf/Compiler.h>
    3030#include <wtf/RetainPtr.h>
     31#include <wtf/UniqueRef.h>
    3132
    3233OBJC_CLASS NSData;
     
    3637
    3738class ParentalControlsContentFilter final : public PlatformContentFilter {
    38     friend std::unique_ptr<ParentalControlsContentFilter> std::make_unique<ParentalControlsContentFilter>();
     39    friend UniqueRef<ParentalControlsContentFilter> WTF::makeUniqueRefWithoutFastMallocCheck<ParentalControlsContentFilter>();
    3940
    4041public:
    41     static std::unique_ptr<ParentalControlsContentFilter> create();
     42    static UniqueRef<ParentalControlsContentFilter> create();
    4243
    4344    void willSendRequest(ResourceRequest&, const ResourceResponse&) override { }
  • trunk/Source/WebCore/platform/cocoa/ParentalControlsContentFilter.mm

    r253440 r254983  
    6868}
    6969
    70 std::unique_ptr<ParentalControlsContentFilter> ParentalControlsContentFilter::create()
     70UniqueRef<ParentalControlsContentFilter> ParentalControlsContentFilter::create()
    7171{
    72     return makeUnique<ParentalControlsContentFilter>();
     72    return makeUniqueRef<ParentalControlsContentFilter>();
    7373}
    7474
  • trunk/Source/WebCore/testing/MockContentFilter.cpp

    r248846 r254983  
    6363}
    6464
    65 std::unique_ptr<MockContentFilter> MockContentFilter::create()
     65UniqueRef<MockContentFilter> MockContentFilter::create()
    6666{
    67     return makeUnique<MockContentFilter>();
     67    return makeUniqueRef<MockContentFilter>();
    6868}
    6969
  • trunk/Source/WebCore/testing/MockContentFilter.h

    r208668 r254983  
    2828#include "MockContentFilterSettings.h"
    2929#include "PlatformContentFilter.h"
     30#include <wtf/UniqueRef.h>
    3031
    3132namespace WebCore {
    3233
    3334class MockContentFilter final : public PlatformContentFilter {
    34     friend std::unique_ptr<MockContentFilter> std::make_unique<MockContentFilter>();
     35    friend UniqueRef<MockContentFilter> WTF::makeUniqueRefWithoutFastMallocCheck<MockContentFilter>();
    3536
    3637public:
    3738    static void ensureInstalled();
    38     static std::unique_ptr<MockContentFilter> create();
     39    static UniqueRef<MockContentFilter> create();
    3940
    4041    void willSendRequest(ResourceRequest&, const ResourceResponse&) override;
Note: See TracChangeset for help on using the changeset viewer.