ResourceResponseBase.cpp [plain text]
#include "config.h"
#include "ResourceResponseBase.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 {
static void parseCacheHeader(const String& header, Vector<std::pair<String, String>>& result);
inline const ResourceResponse& ResourceResponseBase::asResourceResponse() const
{
return *static_cast<const ResourceResponse*>(this);
}
ResourceResponseBase::ResourceResponseBase()
: m_expectedContentLength(0)
, m_httpStatusCode(0)
, m_connectionID(0)
, m_cacheControlMaxAge(0)
, m_age(0)
, m_date(0)
, m_expires(0)
, m_lastModified(0)
, m_wasCached(false)
, m_connectionReused(false)
, m_isNull(true)
, m_haveParsedCacheControlHeader(false)
, m_haveParsedAgeHeader(false)
, m_haveParsedDateHeader(false)
, m_haveParsedExpiresHeader(false)
, m_haveParsedLastModifiedHeader(false)
, m_cacheControlContainsNoCache(false)
, m_cacheControlContainsNoStore(false)
, m_cacheControlContainsMustRevalidate(false)
{
}
ResourceResponseBase::ResourceResponseBase(const URL& url, const String& mimeType, long long expectedLength, const String& textEncodingName, const String& filename)
: m_url(url)
, m_mimeType(mimeType)
, m_expectedContentLength(expectedLength)
, m_textEncodingName(textEncodingName)
, m_suggestedFilename(filename)
, m_httpStatusCode(0)
, m_connectionID(0)
, m_cacheControlMaxAge(0)
, m_age(0)
, m_date(0)
, m_expires(0)
, m_lastModified(0)
, m_wasCached(false)
, m_connectionReused(false)
, m_isNull(false)
, m_haveParsedCacheControlHeader(false)
, m_haveParsedAgeHeader(false)
, m_haveParsedDateHeader(false)
, m_haveParsedExpiresHeader(false)
, m_haveParsedLastModifiedHeader(false)
, m_cacheControlContainsNoCache(false)
, m_cacheControlContainsNoStore(false)
, m_cacheControlContainsMustRevalidate(false)
{
}
PassOwnPtr<ResourceResponse> ResourceResponseBase::adopt(PassOwnPtr<CrossThreadResourceResponseData> data)
{
OwnPtr<ResourceResponse> response = adoptPtr(new ResourceResponse);
response->setURL(data->m_url);
response->setMimeType(data->m_mimeType);
response->setExpectedContentLength(data->m_expectedContentLength);
response->setTextEncodingName(data->m_textEncodingName);
response->setSuggestedFilename(data->m_suggestedFilename);
response->setHTTPStatusCode(data->m_httpStatusCode);
response->setHTTPStatusText(data->m_httpStatusText);
response->lazyInit(CommonAndUncommonFields);
response->m_httpHeaderFields.adopt(WTF::move(data->m_httpHeaders));
response->m_resourceLoadTiming = data->m_resourceLoadTiming;
response->doPlatformAdopt(data);
return response.release();
}
PassOwnPtr<CrossThreadResourceResponseData> ResourceResponseBase::copyData() const
{
OwnPtr<CrossThreadResourceResponseData> data = adoptPtr(new CrossThreadResourceResponseData);
data->m_url = url().copy();
data->m_mimeType = mimeType().isolatedCopy();
data->m_expectedContentLength = expectedContentLength();
data->m_textEncodingName = textEncodingName().isolatedCopy();
data->m_suggestedFilename = suggestedFilename().isolatedCopy();
data->m_httpStatusCode = httpStatusCode();
data->m_httpStatusText = httpStatusText().isolatedCopy();
data->m_httpHeaders = httpHeaderFields().copyData();
data->m_resourceLoadTiming = m_resourceLoadTiming;
return asResourceResponse().doPlatformCopyData(data.release());
}
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;
}
const String& ResourceResponseBase::suggestedFilename() const
{
lazyInit(AllFields);
return m_suggestedFilename;
}
void ResourceResponseBase::setSuggestedFilename(const String& suggestedName)
{
lazyInit(AllFields);
m_isNull = false;
m_suggestedFilename = suggestedName;
}
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(CommonAndUncommonFields);
return m_httpStatusText;
}
void ResourceResponseBase::setHTTPStatusText(const String& statusText)
{
lazyInit(CommonAndUncommonFields);
m_httpStatusText = statusText;
}
String ResourceResponseBase::httpHeaderField(const String& name) const
{
lazyInit(CommonFieldsOnly);
String value = m_httpHeaderFields.get(name);
if (!value.isEmpty())
return value;
lazyInit(CommonAndUncommonFields);
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(CommonAndUncommonFields);
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(CommonAndUncommonFields);
HTTPHeaderName headerName;
if (findHTTPHeaderName(name, headerName))
updateHeaderParsedState(headerName);
m_httpHeaderFields.set(name, value);
}
void ResourceResponseBase::setHTTPHeaderField(HTTPHeaderName name, const String& value)
{
lazyInit(CommonAndUncommonFields);
updateHeaderParsedState(name);
m_httpHeaderFields.set(name, value);
}
void ResourceResponseBase::addHTTPHeaderField(const String& name, const String& value)
{
lazyInit(CommonAndUncommonFields);
HTTPHeaderName headerName;
if (findHTTPHeaderName(name, headerName))
updateHeaderParsedState(headerName);
m_httpHeaderFields.add(name, value);
}
const HTTPHeaderMap& ResourceResponseBase::httpHeaderFields() const
{
lazyInit(CommonAndUncommonFields);
return m_httpHeaderFields;
}
void ResourceResponseBase::parseCacheControlDirectives() const
{
ASSERT(!m_haveParsedCacheControlHeader);
lazyInit(CommonFieldsOnly);
m_haveParsedCacheControlHeader = true;
m_cacheControlContainsMustRevalidate = false;
m_cacheControlContainsNoCache = false;
m_cacheControlMaxAge = std::numeric_limits<double>::quiet_NaN();
String cacheControlValue = m_httpHeaderFields.get(HTTPHeaderName::CacheControl);
if (!cacheControlValue.isEmpty()) {
Vector<std::pair<String, String>> directives;
parseCacheHeader(cacheControlValue, directives);
size_t directivesSize = directives.size();
for (size_t i = 0; i < directivesSize; ++i) {
if (equalIgnoringCase(directives[i].first, "no-cache") && directives[i].second.isEmpty())
m_cacheControlContainsNoCache = true;
else if (equalIgnoringCase(directives[i].first, "no-store"))
m_cacheControlContainsNoStore = true;
else if (equalIgnoringCase(directives[i].first, "must-revalidate"))
m_cacheControlContainsMustRevalidate = true;
else if (equalIgnoringCase(directives[i].first, "max-age")) {
if (!std::isnan(m_cacheControlMaxAge)) {
continue;
}
bool ok;
double maxAge = directives[i].second.toDouble(&ok);
if (ok)
m_cacheControlMaxAge = maxAge;
}
}
}
if (!m_cacheControlContainsNoCache) {
String pragmaValue = m_httpHeaderFields.get(HTTPHeaderName::Pragma);
m_cacheControlContainsNoCache = pragmaValue.contains("no-cache", false);
}
}
bool ResourceResponseBase::cacheControlContainsNoCache() const
{
if (!m_haveParsedCacheControlHeader)
parseCacheControlDirectives();
return m_cacheControlContainsNoCache;
}
bool ResourceResponseBase::cacheControlContainsNoStore() const
{
if (!m_haveParsedCacheControlHeader)
parseCacheControlDirectives();
return m_cacheControlContainsNoStore;
}
bool ResourceResponseBase::cacheControlContainsMustRevalidate() const
{
if (!m_haveParsedCacheControlHeader)
parseCacheControlDirectives();
return m_cacheControlContainsMustRevalidate;
}
bool ResourceResponseBase::hasCacheValidatorFields() const
{
lazyInit(CommonFieldsOnly);
return !m_httpHeaderFields.get(HTTPHeaderName::LastModified).isEmpty() || !m_httpHeaderFields.get(HTTPHeaderName::ETag).isEmpty();
}
double ResourceResponseBase::cacheControlMaxAge() const
{
if (!m_haveParsedCacheControlHeader)
parseCacheControlDirectives();
return m_cacheControlMaxAge;
}
static double parseDateValueInHeader(const HTTPHeaderMap& headers, HTTPHeaderName headerName)
{
String headerValue = headers.get(headerName);
if (headerValue.isEmpty())
return std::numeric_limits<double>::quiet_NaN();
double dateInMilliseconds = parseDate(headerValue);
if (!std::isfinite(dateInMilliseconds))
return std::numeric_limits<double>::quiet_NaN();
return dateInMilliseconds / 1000;
}
double ResourceResponseBase::date() const
{
lazyInit(CommonFieldsOnly);
if (!m_haveParsedDateHeader) {
m_date = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Date);
m_haveParsedDateHeader = true;
}
return m_date;
}
double ResourceResponseBase::age() const
{
lazyInit(CommonFieldsOnly);
if (!m_haveParsedAgeHeader) {
String headerValue = m_httpHeaderFields.get(HTTPHeaderName::Age);
bool ok;
m_age = headerValue.toDouble(&ok);
if (!ok)
m_age = std::numeric_limits<double>::quiet_NaN();
m_haveParsedAgeHeader = true;
}
return m_age;
}
double ResourceResponseBase::expires() const
{
lazyInit(CommonFieldsOnly);
if (!m_haveParsedExpiresHeader) {
m_expires = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::Expires);
m_haveParsedExpiresHeader = true;
}
return m_expires;
}
double ResourceResponseBase::lastModified() const
{
lazyInit(CommonFieldsOnly);
if (!m_haveParsedLastModifiedHeader) {
m_lastModified = parseDateValueInHeader(m_httpHeaderFields, HTTPHeaderName::LastModified);
m_haveParsedLastModifiedHeader = true;
}
return m_lastModified;
}
bool ResourceResponseBase::isAttachment() const
{
lazyInit(CommonAndUncommonFields);
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");
}
bool ResourceResponseBase::wasCached() const
{
lazyInit(CommonAndUncommonFields);
return m_wasCached;
}
void ResourceResponseBase::setWasCached(bool value)
{
m_wasCached = value;
}
bool ResourceResponseBase::connectionReused() const
{
lazyInit(CommonAndUncommonFields);
return m_connectionReused;
}
void ResourceResponseBase::setConnectionReused(bool connectionReused)
{
lazyInit(CommonAndUncommonFields);
m_connectionReused = connectionReused;
}
unsigned ResourceResponseBase::connectionID() const
{
lazyInit(CommonAndUncommonFields);
return m_connectionID;
}
void ResourceResponseBase::setConnectionID(unsigned connectionID)
{
lazyInit(CommonAndUncommonFields);
m_connectionID = connectionID;
}
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);
}
static bool isCacheHeaderSeparator(UChar c)
{
switch (c) {
case '(':
case ')':
case '<':
case '>':
case '@':
case ',':
case ';':
case ':':
case '\\':
case '"':
case '/':
case '[':
case ']':
case '?':
case '=':
case '{':
case '}':
case ' ':
case '\t':
return true;
default:
return false;
}
}
static bool isControlCharacter(UChar c)
{
return c < ' ' || c == 127;
}
static inline String trimToNextSeparator(const String& str)
{
return str.substring(0, str.find(isCacheHeaderSeparator));
}
static void parseCacheHeader(const String& header, Vector<std::pair<String, String>>& result)
{
const String safeHeader = header.removeCharacters(isControlCharacter);
unsigned max = safeHeader.length();
for (unsigned pos = 0; pos < max; ) {
size_t nextCommaPosition = safeHeader.find(',', pos);
size_t nextEqualSignPosition = safeHeader.find('=', pos);
if (nextEqualSignPosition != notFound && (nextEqualSignPosition < nextCommaPosition || nextCommaPosition == notFound)) {
String directive = trimToNextSeparator(safeHeader.substring(pos, nextEqualSignPosition - pos).stripWhiteSpace());
pos += nextEqualSignPosition - pos + 1;
String value = safeHeader.substring(pos, max - pos).stripWhiteSpace();
if (value[0] == '"') {
size_t nextDoubleQuotePosition = value.find('"', 1);
if (nextDoubleQuotePosition != notFound) {
result.append(std::pair<String, String>(directive, value.substring(1, nextDoubleQuotePosition - 1).stripWhiteSpace()));
pos += (safeHeader.find('"', pos) - pos) + nextDoubleQuotePosition + 1;
size_t nextCommaPosition2 = safeHeader.find(',', pos);
if (nextCommaPosition2 != notFound)
pos += nextCommaPosition2 - pos + 1;
else
return; } else {
result.append(std::pair<String, String>(directive, trimToNextSeparator(value.substring(1, value.length() - 1).stripWhiteSpace())));
return;
}
} else {
size_t nextCommaPosition2 = value.find(',');
if (nextCommaPosition2 != notFound) {
result.append(std::pair<String, String>(directive, trimToNextSeparator(value.substring(0, nextCommaPosition2).stripWhiteSpace())));
pos += (safeHeader.find(',', pos) - pos) + 1;
} else {
result.append(std::pair<String, String>(directive, trimToNextSeparator(value)));
return;
}
}
} else if (nextCommaPosition != notFound && (nextCommaPosition < nextEqualSignPosition || nextEqualSignPosition == notFound)) {
result.append(std::pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, nextCommaPosition - pos).stripWhiteSpace()), ""));
pos += nextCommaPosition - pos + 1;
} else {
result.append(std::pair<String, String>(trimToNextSeparator(safeHeader.substring(pos, max - pos).stripWhiteSpace()), ""));
return;
}
}
}
}