ResourceResponseBase.h [plain text]
#pragma once
#include "CacheValidation.h"
#include "CertificateInfo.h"
#include "HTTPHeaderMap.h"
#include "ParsedContentRange.h"
#include "ResourceLoadTiming.h"
#include "URL.h"
namespace WebCore {
class ResourceResponse;
class ResourceResponseBase {
WTF_MAKE_FAST_ALLOCATED;
public:
enum class Type;
struct CrossThreadData {
CrossThreadData(const CrossThreadData&) = delete;
CrossThreadData& operator=(const CrossThreadData&) = delete;
CrossThreadData() = default;
CrossThreadData(CrossThreadData&&) = default;
URL url;
String mimeType;
long long expectedContentLength;
String textEncodingName;
int httpStatusCode;
String httpStatusText;
String httpVersion;
HTTPHeaderMap httpHeaderFields;
ResourceLoadTiming resourceLoadTiming;
Type type;
bool isRedirected;
};
CrossThreadData crossThreadData() const;
static ResourceResponse fromCrossThreadData(CrossThreadData&&);
bool isNull() const { return m_isNull; }
WEBCORE_EXPORT bool isHTTP() const;
bool isSuccessful() const;
WEBCORE_EXPORT const URL& url() const;
WEBCORE_EXPORT void setURL(const URL&);
WEBCORE_EXPORT const String& mimeType() const;
WEBCORE_EXPORT void setMimeType(const String& mimeType);
WEBCORE_EXPORT long long expectedContentLength() const;
WEBCORE_EXPORT void setExpectedContentLength(long long expectedContentLength);
WEBCORE_EXPORT const String& textEncodingName() const;
WEBCORE_EXPORT void setTextEncodingName(const String& name);
WEBCORE_EXPORT int httpStatusCode() const;
WEBCORE_EXPORT void setHTTPStatusCode(int);
WEBCORE_EXPORT const String& httpStatusText() const;
WEBCORE_EXPORT void setHTTPStatusText(const String&);
WEBCORE_EXPORT const String& httpVersion() const;
WEBCORE_EXPORT void setHTTPVersion(const String&);
bool isHttpVersion0_9() const;
WEBCORE_EXPORT const HTTPHeaderMap& httpHeaderFields() const;
String httpHeaderField(const String& name) const;
WEBCORE_EXPORT String httpHeaderField(HTTPHeaderName) const;
WEBCORE_EXPORT void setHTTPHeaderField(const String& name, const String& value);
void setHTTPHeaderField(HTTPHeaderName, const String& value);
void addHTTPHeaderField(HTTPHeaderName, const String& value);
void addHTTPHeaderField(const String& name, const String& value);
template<size_t length> String httpHeaderField(const char (&)[length]) const = delete;
template<size_t length> void setHTTPHeaderField(const char (&)[length], const String&) = delete;
template<size_t length> void addHTTPHeaderField(const char (&)[length], const String&) = delete;
bool isMultipart() const { return mimeType() == "multipart/x-mixed-replace"; }
WEBCORE_EXPORT bool isAttachment() const;
WEBCORE_EXPORT String suggestedFilename() const;
WEBCORE_EXPORT void includeCertificateInfo() const;
WEBCORE_EXPORT const Optional<CertificateInfo>& certificateInfo() const { return m_certificateInfo; };
WEBCORE_EXPORT bool cacheControlContainsNoCache() const;
WEBCORE_EXPORT bool cacheControlContainsNoStore() const;
WEBCORE_EXPORT bool cacheControlContainsMustRevalidate() const;
WEBCORE_EXPORT bool hasCacheValidatorFields() const;
WEBCORE_EXPORT Optional<std::chrono::microseconds> cacheControlMaxAge() const;
WEBCORE_EXPORT Optional<std::chrono::system_clock::time_point> date() const;
WEBCORE_EXPORT Optional<std::chrono::microseconds> age() const;
WEBCORE_EXPORT Optional<std::chrono::system_clock::time_point> expires() const;
WEBCORE_EXPORT Optional<std::chrono::system_clock::time_point> lastModified() const;
ParsedContentRange& contentRange() const;
enum class Source { Unknown, Network, DiskCache, DiskCacheAfterValidation, MemoryCache, MemoryCacheAfterValidation };
WEBCORE_EXPORT Source source() const;
WEBCORE_EXPORT void setSource(Source);
ResourceLoadTiming& resourceLoadTiming() const { return m_resourceLoadTiming; }
unsigned memoryUsage() const
{
return 1280;
}
enum class Type { Basic, Cors, Default, Error, Opaque, Opaqueredirect };
Type type() const { return m_type; }
void setType(Type type) { m_type = type; }
bool isRedirected() const { return m_isRedirected; }
void setRedirected(bool isRedirected) { m_isRedirected = isRedirected; }
static bool compare(const ResourceResponse&, const ResourceResponse&);
template<class Encoder> void encode(Encoder&) const;
template<class Decoder> static bool decode(Decoder&, ResourceResponseBase&);
protected:
enum InitLevel {
Uninitialized,
CommonFieldsOnly,
AllFields
};
WEBCORE_EXPORT ResourceResponseBase();
WEBCORE_EXPORT ResourceResponseBase(const URL&, const String& mimeType, long long expectedLength, const String& textEncodingName);
WEBCORE_EXPORT void lazyInit(InitLevel) const;
void platformLazyInit(InitLevel) { }
CertificateInfo platformCertificateInfo() const { return CertificateInfo(); };
String platformSuggestedFileName() const { return String(); }
static bool platformCompare(const ResourceResponse&, const ResourceResponse&) { return true; }
private:
void parseCacheControlDirectives() const;
void updateHeaderParsedState(HTTPHeaderName);
protected:
bool m_isNull;
URL m_url;
AtomicString m_mimeType;
long long m_expectedContentLength;
AtomicString m_textEncodingName;
AtomicString m_httpStatusText;
AtomicString m_httpVersion;
HTTPHeaderMap m_httpHeaderFields;
mutable ResourceLoadTiming m_resourceLoadTiming;
mutable Optional<CertificateInfo> m_certificateInfo;
int m_httpStatusCode;
private:
mutable Optional<std::chrono::microseconds> m_age;
mutable Optional<std::chrono::system_clock::time_point> m_date;
mutable Optional<std::chrono::system_clock::time_point> m_expires;
mutable Optional<std::chrono::system_clock::time_point> m_lastModified;
mutable ParsedContentRange m_contentRange;
mutable CacheControlDirectives m_cacheControlDirectives;
mutable bool m_haveParsedCacheControlHeader { false };
mutable bool m_haveParsedAgeHeader { false };
mutable bool m_haveParsedDateHeader { false };
mutable bool m_haveParsedExpiresHeader { false };
mutable bool m_haveParsedLastModifiedHeader { false };
mutable bool m_haveParsedContentRangeHeader { false };
Source m_source { Source::Unknown };
Type m_type { Type::Default };
bool m_isRedirected { false };
};
inline bool operator==(const ResourceResponse& a, const ResourceResponse& b) { return ResourceResponseBase::compare(a, b); }
inline bool operator!=(const ResourceResponse& a, const ResourceResponse& b) { return !(a == b); }
template<class Encoder>
void ResourceResponseBase::encode(Encoder& encoder) const
{
encoder << m_isNull;
if (m_isNull)
return;
lazyInit(AllFields);
encoder << m_url;
encoder << m_mimeType;
encoder << static_cast<int64_t>(m_expectedContentLength);
encoder << m_textEncodingName;
encoder << m_httpStatusText;
encoder << m_httpVersion;
encoder << m_httpHeaderFields;
encoder << m_resourceLoadTiming;
encoder << m_httpStatusCode;
encoder << m_certificateInfo;
encoder.encodeEnum(m_source);
encoder.encodeEnum(m_type);
encoder << m_isRedirected;
}
template<class Decoder>
bool ResourceResponseBase::decode(Decoder& decoder, ResourceResponseBase& response)
{
ASSERT(response.m_isNull);
bool responseIsNull;
if (!decoder.decode(responseIsNull))
return false;
if (responseIsNull)
return true;
if (!decoder.decode(response.m_url))
return false;
if (!decoder.decode(response.m_mimeType))
return false;
int64_t expectedContentLength;
if (!decoder.decode(expectedContentLength))
return false;
response.m_expectedContentLength = expectedContentLength;
if (!decoder.decode(response.m_textEncodingName))
return false;
if (!decoder.decode(response.m_httpStatusText))
return false;
if (!decoder.decode(response.m_httpVersion))
return false;
if (!decoder.decode(response.m_httpHeaderFields))
return false;
if (!decoder.decode(response.m_resourceLoadTiming))
return false;
if (!decoder.decode(response.m_httpStatusCode))
return false;
if (!decoder.decode(response.m_certificateInfo))
return false;
if (!decoder.decodeEnum(response.m_source))
return false;
if (!decoder.decodeEnum(response.m_type))
return false;
if (!decoder.decode(response.m_isRedirected))
return false;
response.m_isNull = false;
return true;
}
}