ResourceResponseBase.cpp [plain text]
#include "config.h"
#include "ResourceResponseBase.h"
#include "CacheValidation.h"
#include "HTTPHeaderNames.h"
#include "HTTPParsers.h"
#include "ResourceResponse.h"
#include <wtf/CurrentTime.h>
#include <wtf/MathExtras.h>
#include <wtf/StdLibExtras.h>
#include <wtf/text/StringView.h>
namespace WebCore {
inline const ResourceResponse& ResourceResponseBase::asResourceResponse() const
{
return *static_cast<const ResourceResponse*>(this);
}
ResourceResponseBase::ResourceResponseBase()
: m_isNull(true)
, m_expectedContentLength(0)
, m_includesCertificateInfo(false)
, m_httpStatusCode(0)
{
}
ResourceResponseBase::ResourceResponseBase(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName)
: m_isNull(false)
, m_url(url)
, m_mimeType(mimeType)
, m_expectedContentLength(expectedLength)
, m_textEncodingName(textEncodingName)
, m_includesCertificateInfo(true) , m_httpStatusCode(0)
{
}
std::unique_ptr<ResourceResponse> ResourceResponseBase::adopt(std::unique_ptr<CrossThreadResourceResponseData> data)
{
auto response = std::make_unique<ResourceResponse>();
response->setURL(data->m_url);
response->setMimeType(data->m_mimeType);
response->setExpectedContentLength(data->m_expectedContentLength);
response->setTextEncodingName(data->m_textEncodingName);
response->setHTTPStatusCode(data->m_httpStatusCode);
response->setHTTPStatusText(data->m_httpStatusText);
response->setHTTPVersion(data->m_httpVersion);
response->lazyInit(AllFields);
response->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));
response->m_resourceLoadTiming = data->m_resourceLoadTiming;
response->doPlatformAdopt(WTF::move(data));
return response;
}
std::unique_ptr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
{
auto data = std::make_unique<CrossThreadResourceResponseData>();
data->m_url = url().isolatedCopy();
data->m_mimeType = mimeType().isolatedCopy();
data->m_expectedContentLength = expectedContentLength();
data->m_textEncodingName = textEncodingName().isolatedCopy();
data->m_httpStatusCode = httpStatusCode();
data->m_httpStatusText = httpStatusText().isolatedCopy();
data->m_httpVersion = httpVersion().isolatedCopy();
data->m_httpHeaders = httpHeaderFields().copyData();
data->m_resourceLoadTiming = m_resourceLoadTiming;
return asResourceResponse().doPlatformCopyData(WTF::move(data));
}
bool ResourceResponseBase::isHTTP() const
{
lazyInit(CommonFieldsOnly);
String protocol = m_url.protocol();
return equalIgnoringCase(protocol, "http") || equalIgnoringCase(protocol, "https");
}
const URL& ResourceResponseBase::url() const
{
lazyInit(CommonFieldsOnly);
return m_url;
}
void ResourceResponseBase::setURL(const URL& url)
{
lazyInit(CommonFieldsOnly);
m_isNull = false;
m_url = url;
}
const String& ResourceResponseBase::mimeType() const
{
lazyInit(CommonFieldsOnly);
return m_mimeType;
}
void ResourceResponseBase::setMimeType(const String& mimeType)
{
lazyInit(CommonFieldsOnly);
m_isNull = false;
m_mimeType = mimeType;
}
long long ResourceResponseBase::expectedContentLength() const
{
lazyInit(CommonFieldsOnly);
return m_expectedContentLength;
}
void ResourceResponseBase::setExpectedContentLength(long long expectedContentLength)
{
lazyInit(CommonFieldsOnly);
m_isNull = false;
m_expectedContentLength = expectedContentLength;
}
const String& ResourceResponseBase::textEncodingName() const
{
lazyInit(CommonFieldsOnly);
return m_textEncodingName;
}
void ResourceResponseBase::setTextEncodingName(const String& encodingName)
{
lazyInit(CommonFieldsOnly);
m_isNull = false;
m_textEncodingName = encodingName;
}
void ResourceResponseBase::includeCertificateInfo() const
{
if (m_includesCertificateInfo)
return;
m_certificateInfo = static_cast<const ResourceResponse*>(this)->platformCertificateInfo();
m_includesCertificateInfo = true;
}
CertificateInfo ResourceResponseBase::certificateInfo() const
{
return m_certificateInfo;
}
String ResourceResponseBase::suggestedFilename() const
{
return static_cast<const ResourceResponse*>(this)->platformSuggestedFilename();
}
int ResourceResponseBase::httpStatusCode() const
{
lazyInit(CommonFieldsOnly);
return m_httpStatusCode;
}
void ResourceResponseBase::setHTTPStatusCode(int statusCode)
{
lazyInit(CommonFieldsOnly);
m_httpStatusCode = statusCode;
}
const String& ResourceResponseBase::httpStatusText() const
{
lazyInit(AllFields);
return m_httpStatusText;
}
void ResourceResponseBase::setHTTPStatusText(const String& statusText)
{
lazyInit(AllFields);
m_httpStatusText = statusText;
}
const String& ResourceResponseBase::httpVersion() const
{
lazyInit(AllFields);
return m_httpVersion;
}
void ResourceResponseBase::setHTTPVersion(const String& versionText)
{
lazyInit(AllFields);
m_httpVersion = versionText;
}
bool ResourceResponseBase::isHttpVersion0_9() const
{
lazyInit(AllFields);
return m_httpVersion.startsWith("HTTP/0.9");
}
String ResourceResponseBase::httpHeaderField(const String& name) const
{
lazyInit(CommonFieldsOnly);
String value = m_httpHeaderFields.get(name);
if (!value.isEmpty())
return value;
lazyInit(AllFields);
return m_httpHeaderFields.get(name);
}
String ResourceResponseBase::httpHeaderField(HTTPHeaderName name) const
{
lazyInit(CommonFieldsOnly);
String value = m_httpHeaderFields.get(name);
if (!value.isEmpty())
return value;
lazyInit(AllFields);
return m_httpHeaderFields.get(name);
}
void ResourceResponseBase::updateHeaderParsedState(HTTPHeaderName name)
{
switch (name) {
case HTTPHeaderName::Age:
m_haveParsedAgeHeader = false;
break;
case HTTPHeaderName::CacheControl:
case HTTPHeaderName::Pragma:
m_haveParsedCacheControlHeader = false;
break;
case HTTPHeaderName::Date:
m_haveParsedDateHeader = false;
break;
case HTTPHeaderName::Expires:
m_haveParsedExpiresHeader = false;
break;
case HTTPHeaderName::LastModified:
m_haveParsedLastModifiedHeader = false;
break;
default:
break;
}
}
void ResourceResponseBase::setHTTPHeaderField(const String& name, const String& value)
{
lazyInit(AllFields);
HTTPHeaderName headerName;
if (findHTTPHeaderName(name, headerName))
updateHeaderParsedState(headerName);
m_httpHeaderFields.set(name, value);
}
void ResourceResponseBase::setHTTPHeaderField(HTTPHeaderName name, const String& value)
{
lazyInit(AllFields);
updateHeaderParsedState(name);
m_httpHeaderFields.set(name, value);
}
void ResourceResponseBase::addHTTPHeaderField(const String& name, const String& value)
{
lazyInit(AllFields);
HTTPHeaderName headerName;
if (findHTTPHeaderName(name, headerName))
updateHeaderParsedState(headerName);
m_httpHeaderFields.add(name, value);
}
const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
{
lazyInit(AllFields);
return m_httpHeaderFields;
}
void ResourceResponseBase::parseCacheControlDirectives() const
{
ASSERT(!m_haveParsedCacheControlHeader);
lazyInit(CommonFieldsOnly);
m_cacheControlDirectives = WebCore::parseCacheControlDirectives(m_httpHeaderFields);
m_haveParsedCacheControlHeader = true;
}
bool ResourceResponseBase::cacheControlContainsNoCache() const
{
if (!m_haveParsedCacheControlHeader)
parseCacheControlDirectives();
return m_cacheControlDirectives.noCache;
}
bool ResourceResponseBase::cacheControlContainsNoStore() const
{
if (!m_haveParsedCacheControlHeader)
parseCacheControlDirectives();
return m_cacheControlDirectives.noStore;
}
bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
{
if (!m_haveParsedCacheControlHeader)
parseCacheControlDirectives();
return m_cacheControlDirectives.mustRevalidate;
}
bool ResourceResponseBase::hasCacheValidatorFields() const
{
lazyInit(CommonFieldsOnly);
return !m_httpHeaderFields.get(HTTPHeaderName::LastModified).isEmpty() || !m_httpHeaderFields.get(HTTPHeaderName::ETag).isEmpty();
}
Optional<std::chrono::microseconds> ResourceResponseBase::cacheControlMaxAge() const
{
if (!m_haveParsedCacheControlHeader)
parseCacheControlDirectives();
return m_cacheControlDirectives.maxAge;
}
static Optional<std::chrono::system_clock::time_point> parseDateValueInHeader(const HTTPHeaderMap& headers, HTTPHeaderName headerName)
{
String headerValue = headers.get(headerName);
if (headerValue.isEmpty())
return { };
return parseHTTPDate(headerValue);
}
Optional<std::chrono::system_clock::time_point> ResourceResponseBase::date() const
{
lazyInit(CommonFieldsOnly);
if (!m_haveParsedDateHeader) {
m_date = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Date);
m_haveParsedDateHeader = true;
}
return m_date;
}
Optional<std::chrono::microseconds> ResourceResponseBase::age() const
{
using namespace std::chrono;
lazyInit(CommonFieldsOnly);
if (!m_haveParsedAgeHeader) {
String headerValue = m_httpHeaderFields.get(HTTPHeaderName::Age);
bool ok;
double ageDouble = headerValue.toDouble(&ok);
if (ok)
m_age = duration_cast<microseconds>(duration<double>(ageDouble));
m_haveParsedAgeHeader = true;
}
return m_age;
}
Optional<std::chrono::system_clock::time_point> ResourceResponseBase::expires() const
{
lazyInit(CommonFieldsOnly);
if (!m_haveParsedExpiresHeader) {
m_expires = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Expires);
m_haveParsedExpiresHeader = true;
}
return m_expires;
}
Optional<std::chrono::system_clock::time_point> ResourceResponseBase::lastModified() const
{
lazyInit(CommonFieldsOnly);
if (!m_haveParsedLastModifiedHeader) {
m_lastModified = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::LastModified);
#if PLATFORM(COCOA)
const std::chrono::system_clock::time_point epoch;
if (m_lastModified && m_lastModified.value() == epoch)
m_lastModified = Nullopt;
#endif
m_haveParsedLastModifiedHeader = true;
}
return m_lastModified;
}
bool ResourceResponseBase::isAttachment() const
{
lazyInit(AllFields);
String value = m_httpHeaderFields.get(HTTPHeaderName::ContentDisposition);
size_t loc = value.find(';');
if (loc != notFound)
value = value.left(loc);
value = value.stripWhiteSpace();
return equalIgnoringCase(value, "attachment");
}
ResourceResponseBase::Source ResourceResponseBase::source() const
{
lazyInit(AllFields);
return m_source;
}
void ResourceResponseBase::setSource(Source source)
{
m_source = source;
}
void ResourceResponseBase::lazyInit(InitLevel initLevel) const
{
const_cast<ResourceResponse*>(static_cast<const ResourceResponse*>(this))->platformLazyInit(initLevel);
}
bool ResourceResponseBase::compare(const ResourceResponse& a, const ResourceResponse& b)
{
if (a.isNull() != b.isNull())
return false;
if (a.url() != b.url())
return false;
if (a.mimeType() != b.mimeType())
return false;
if (a.expectedContentLength() != b.expectedContentLength())
return false;
if (a.textEncodingName() != b.textEncodingName())
return false;
if (a.suggestedFilename() != b.suggestedFilename())
return false;
if (a.httpStatusCode() != b.httpStatusCode())
return false;
if (a.httpStatusText() != b.httpStatusText())
return false;
if (a.httpHeaderFields() != b.httpHeaderFields())
return false;
if (a.resourceLoadTiming() != b.resourceLoadTiming())
return false;
return ResourceResponse::platformCompare(a, b);
}
}