#pragma once
#if ENABLE(CONTENT_FILTERING)
#include "CachedResourceHandle.h"
#include "PlatformContentFilter.h"
#include "ResourceError.h"
#include <functional>
#include <wtf/Forward.h>
namespace WebCore {
class CachedRawResource;
class DocumentLoader;
class ResourceRequest;
class ResourceResponse;
class SubstituteData;
class ContentFilter {
WTF_MAKE_FAST_ALLOCATED;
WTF_MAKE_NONCOPYABLE(ContentFilter);
public:
template <typename T> static void addType() { types().append(type<T>()); }
static std::unique_ptr<ContentFilter> create(DocumentLoader&);
~ContentFilter();
static const char* urlScheme() { return "x-apple-content-filter"; }
void startFilteringMainResource(CachedRawResource&);
void stopFilteringMainResource();
bool continueAfterWillSendRequest(ResourceRequest&, const ResourceResponse&);
bool continueAfterResponseReceived(const ResourceResponse&);
bool continueAfterDataReceived(const char* data, int length);
bool continueAfterNotifyFinished(CachedResource&);
static bool continueAfterSubstituteDataRequest(const DocumentLoader& activeLoader, const SubstituteData&);
void handleProvisionalLoadFailure(const ResourceError&);
private:
using State = PlatformContentFilter::State;
struct Type {
const std::function<std::unique_ptr<PlatformContentFilter>()> create;
};
template <typename T> static Type type();
WEBCORE_EXPORT static Vector<Type>& types();
using Container = Vector<std::unique_ptr<PlatformContentFilter>>;
friend std::unique_ptr<ContentFilter> std::make_unique<ContentFilter>(Container&&, DocumentLoader&);
ContentFilter(Container&&, DocumentLoader&);
template <typename Function> void forEachContentFilterUntilBlocked(Function&&);
void didDecide(State);
void deliverResourceData(CachedResource&);
const Container m_contentFilters;
DocumentLoader& m_documentLoader;
CachedResourceHandle<CachedRawResource> m_mainResource;
PlatformContentFilter* m_blockingContentFilter { nullptr };
State m_state { State::Stopped };
ResourceError m_blockedError;
bool m_isLoadingBlockedPage { false };
};
template <typename T>
ContentFilter::Type ContentFilter::type()
{
static_assert(std::is_base_of<PlatformContentFilter, T>::value, "Type must be a PlatformContentFilter.");
return { T::create };
}
}
#endif // ENABLE(CONTENT_FILTERING)