NetworkCacheData.h [plain text]
#ifndef NetworkCacheData_h
#define NetworkCacheData_h
#if ENABLE(NETWORK_CACHE)
#include <functional>
#include <wtf/FunctionDispatcher.h>
#include <wtf/SHA1.h>
#include <wtf/ThreadSafeRefCounted.h>
#include <wtf/text/WTFString.h>
#if USE(SOUP)
#include <WebCore/GRefPtrSoup.h>
#endif
namespace WebKit {
class SharedMemory;
namespace NetworkCache {
#if PLATFORM(COCOA)
template <typename T> class DispatchPtr;
template <typename T> DispatchPtr<T> adoptDispatch(T dispatchObject);
template<typename T> class DispatchPtr {
public:
DispatchPtr()
: m_ptr(nullptr)
{
}
explicit DispatchPtr(T ptr)
: m_ptr(ptr)
{
if (m_ptr)
dispatch_retain(m_ptr);
}
DispatchPtr(const DispatchPtr& other)
: m_ptr(other.m_ptr)
{
if (m_ptr)
dispatch_retain(m_ptr);
}
~DispatchPtr()
{
if (m_ptr)
dispatch_release(m_ptr);
}
DispatchPtr& operator=(const DispatchPtr& other)
{
auto copy = other;
std::swap(m_ptr, copy.m_ptr);
return *this;
}
T get() const { return m_ptr; }
explicit operator bool() const { return m_ptr; }
friend DispatchPtr adoptDispatch<T>(T);
private:
struct Adopt { };
DispatchPtr(Adopt, T data)
: m_ptr(data)
{
}
T m_ptr;
};
template <typename T> DispatchPtr<T> adoptDispatch(T dispatchObject)
{
return DispatchPtr<T>(typename DispatchPtr<T>::Adopt { }, dispatchObject);
}
#endif
class Data {
public:
Data() { }
Data(const uint8_t*, size_t);
static Data empty();
static Data adoptMap(void* map, size_t, int fd);
#if PLATFORM(COCOA)
enum class Backing { Buffer, Map };
Data(DispatchPtr<dispatch_data_t>, Backing = Backing::Buffer);
#endif
#if USE(SOUP)
Data(GRefPtr<SoupBuffer>&&, int fd = -1);
#endif
bool isNull() const;
bool isEmpty() const { return !m_size; }
const uint8_t* data() const;
size_t size() const { return m_size; }
bool isMap() const { return m_isMap; }
RefPtr<SharedMemory> tryCreateSharedMemory() const;
Data subrange(size_t offset, size_t) const;
bool apply(const std::function<bool (const uint8_t*, size_t)>&&) const;
Data mapToFile(const char* path) const;
#if PLATFORM(COCOA)
dispatch_data_t dispatchData() const { return m_dispatchData.get(); }
#endif
#if USE(SOUP)
SoupBuffer* soupBuffer() const { return m_buffer.get(); }
#endif
private:
#if PLATFORM(COCOA)
mutable DispatchPtr<dispatch_data_t> m_dispatchData;
#endif
#if USE(SOUP)
mutable GRefPtr<SoupBuffer> m_buffer;
int m_fileDescriptor { -1 };
#endif
mutable const uint8_t* m_data { nullptr };
size_t m_size { 0 };
bool m_isMap { false };
};
Data concatenate(const Data&, const Data&);
bool bytesEqual(const Data&, const Data&);
Data adoptAndMapFile(int fd, size_t offset, size_t);
Data mapFile(const char* path);
SHA1::Digest computeSHA1(const Data&);
}
}
#endif
#endif