void ResourceResponse::updateFromSoupMessage(SoupMessage* soupMessage)
{
SoupURI* soupURI = soup_message_get_uri(soupMessage);
GOwnPtr<gchar> uri(soup_uri_to_string(soupURI, FALSE));
m_url = KURL(KURL(), String::fromUTF8(uri.get()));
m_httpStatusCode = soupMessage->status_code;
SoupMessageHeadersIter headersIter;
const char* headerName;
const char* headerValue;
soup_message_headers_iter_init(&headersIter, soupMessage->response_headers);
while (soup_message_headers_iter_next(&headersIter, &headerName, &headerValue))
m_httpHeaderFields.set(String::fromUTF8(headerName), String::fromUTF8(headerValue));
m_soupFlags = soup_message_get_flags(soupMessage);
String contentType = soup_message_headers_get_one(soupMessage->response_headers, "Content-Type");
setMimeType(extractMIMETypeFromMediaType(contentType));
setTextEncodingName(extractCharsetFromMediaType(contentType));
setExpectedContentLength(soup_message_headers_get_content_length(soupMessage->response_headers));
setHTTPStatusText(soupMessage->reason_phrase);
setSuggestedFilename(filenameFromHTTPContentDisposition(httpHeaderField("Content-Disposition")));
}
const CacheControlDirectiveMap& ResourceResponseBase::parseCacheControlDirectives() const
{
lazyInit();
if (m_haveParsedCacheControlHeader)
return m_cacheControlDirectiveMap;
m_cacheControlDirectiveMap.clear();
m_haveParsedCacheControlHeader = true;
const String cacheControlHeader = httpHeaderField("Cache-Control");
if (cacheControlHeader.isEmpty())
return m_cacheControlDirectiveMap;
Vector<pair<String, String> > directives;
parseCacheHeader(cacheControlHeader, directives);
unsigned iMax = directives.size();
for (unsigned i = 0; i < iMax; ++i) {
Vector<String> directiveValues;
if ((equalIgnoringCase(directives[i].first, "private") || equalIgnoringCase(directives[i].first, "no-cache")) && !directives[i].second.isEmpty())
parseCacheControlDirectiveValues(directives[i].second, directiveValues);
else
directiveValues.append(directives[i].second);
if (m_cacheControlDirectiveMap.contains(directives[i].first)) {
CacheControlDirectiveMap::iterator entry = m_cacheControlDirectiveMap.find(directives[i].first);
unsigned jMax = directiveValues.size();
for (unsigned j = 0; j < jMax; ++j)
entry->second.add(directiveValues[j]);
} else {
HashSet<String> values;
unsigned jMax = directiveValues.size();
for (unsigned j = 0; j < jMax; ++j)
values.add(directiveValues[j]);
m_cacheControlDirectiveMap.set(directives[i].first, values);
}
}
return m_cacheControlDirectiveMap;
}
const PragmaDirectiveMap& ResourceResponseBase::parsePragmaDirectives() const
{
lazyInit();
if (m_haveParsedPragmaHeader)
return m_pragmaDirectiveMap;
m_pragmaDirectiveMap.clear();
m_haveParsedPragmaHeader = true;
const String pragmaHeader = httpHeaderField("Pragma");
if (pragmaHeader.isEmpty())
return m_pragmaDirectiveMap;
Vector<pair<String, String> > directives;
parseCacheHeader(pragmaHeader, directives);
unsigned max = directives.size();
for (unsigned i = 0; i < max; ++i)
m_pragmaDirectiveMap.set(directives[i].first, directives[i].second);
return m_pragmaDirectiveMap;
}
void ResourceResponse::updateFromSoupMessageHeaders(const SoupMessageHeaders* messageHeaders)
{
SoupMessageHeaders* headers = const_cast<SoupMessageHeaders*>(messageHeaders);
SoupMessageHeadersIter headersIter;
const char* headerName;
const char* headerValue;
// updateFromSoupMessage could be called several times for the same ResourceResponse object,
// thus, we need to clear old header values and update m_httpHeaderFields from soupMessage headers.
m_httpHeaderFields.clear();
soup_message_headers_iter_init(&headersIter, headers);
while (soup_message_headers_iter_next(&headersIter, &headerName, &headerValue)) {
String headerNameString = String::fromUTF8WithLatin1Fallback(headerName, strlen(headerName));
HTTPHeaderMap::const_iterator it = m_httpHeaderFields.find(headerNameString);
if (it == m_httpHeaderFields.end() || (it != m_httpHeaderFields.end() && it->value.isEmpty()))
m_httpHeaderFields.set(headerNameString, String::fromUTF8WithLatin1Fallback(headerValue, strlen(headerValue)));
else {
StringBuilder builder;
builder.append(it->value);
builder.appendLiteral(", ");
builder.append(String::fromUTF8WithLatin1Fallback(headerValue, strlen(headerValue)));
m_httpHeaderFields.set(headerNameString, builder.toString());
}
}
String contentType;
const char* officialType = soup_message_headers_get_one(headers, "Content-Type");
if (!m_sniffedContentType.isEmpty() && m_sniffedContentType != officialType)
contentType = m_sniffedContentType;
else
contentType = officialType;
setMimeType(extractMIMETypeFromMediaType(contentType));
setTextEncodingName(extractCharsetFromMediaType(contentType));
setExpectedContentLength(soup_message_headers_get_content_length(headers));
setSuggestedFilename(filenameFromHTTPContentDisposition(httpHeaderField("Content-Disposition")));}
String ResourceRequestBase::httpAccept() const
{
return httpHeaderField(HTTPHeaderName::Accept);
}
String ResourceRequestBase::httpUserAgent() const
{
return httpHeaderField(HTTPHeaderName::UserAgent);
}
String ResourceRequestBase::httpOrigin() const
{
return httpHeaderField(HTTPHeaderName::Origin);
}
String ResourceRequestBase::httpReferrer() const
{
return httpHeaderField(HTTPHeaderName::Referer);
}
String ResourceRequestBase::httpContentType() const
{
return httpHeaderField(HTTPHeaderName::ContentType);
}
String ResourceRequestBase::httpAccept() const
{
return httpHeaderField("Accept");
}
String ResourceRequestBase::httpUserAgent() const
{
return httpHeaderField("User-Agent");
}
String ResourceRequestBase::httpOrigin() const
{
return httpHeaderField("Origin");
}
String ResourceRequestBase::httpReferrer() const
{
return httpHeaderField("Referer");
}
String ResourceRequestBase::httpContentType() const
{
return httpHeaderField("Content-Type");
}
