#ifndef ContentFilter_h
#define ContentFilter_h
#if ENABLE(CONTENT_FILTERING)
#include "CachedRawResourceClient.h"
#include "CachedResourceHandle.h"
#include <functional>
#include <wtf/Vector.h>
namespace WebCore {
class CachedRawResource;
class ContentFilterUnblockHandler;
class PlatformContentFilter;
class SharedBuffer;
class ContentFilter final : private CachedRawResourceClient {
WTF_MAKE_FAST_ALLOCATED;
WTF_MAKE_NONCOPYABLE(ContentFilter);
public:
template <typename T> static void addType() { types().append(type<T>()); }
using DecisionFunction = std::function<void()>;
static std::unique_ptr<ContentFilter> createIfNeeded(DecisionFunction);
~ContentFilter() override;
static const char* urlScheme() { return "x-apple-content-filter"; }
void willSendRequest(ResourceRequest&, const ResourceResponse&);
void startFilteringMainResource(CachedRawResource&);
enum class State {
Initialized,
Filtering,
Allowed,
Blocked
};
State state() const { return m_state; }
ContentFilterUnblockHandler unblockHandler() const;
Ref<SharedBuffer> replacementData() const;
String unblockRequestDeniedScript() const;
private:
struct Type {
const std::function<bool()> enabled;
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&&, DecisionFunction&&);
ContentFilter(Container, DecisionFunction);
void responseReceived(CachedResource*, const ResourceResponse&) override;
void dataReceived(CachedResource*, const char* data, int length) override;
void redirectReceived(CachedResource*, ResourceRequest&, const ResourceResponse&) override;
void notifyFinished(CachedResource*) override;
void forEachContentFilterUntilBlocked(std::function<void(PlatformContentFilter&)>);
void didDecide(State);
const Container m_contentFilters;
const DecisionFunction m_decisionFunction;
CachedResourceHandle<CachedRawResource> m_mainResource;
PlatformContentFilter* m_blockingContentFilter { nullptr };
State m_state { State::Initialized };
};
template <typename T>
ContentFilter::Type ContentFilter::type()
{
static_assert(std::is_base_of<PlatformContentFilter, T>::value, "Type must be a PlatformContentFilter.");
return { T::enabled, T::create };
}
}
#endif // ENABLE(CONTENT_FILTERING)
#endif // ContentFilter_h