Changeset 201801 in webkit


Ignore:
Timestamp:
Jun 8, 2016 2:06:07 AM (8 years ago)
Author:
commit-queue@webkit.org
Message:

Unreviewed, rolling out r201800.
https://bugs.webkit.org/show_bug.cgi?id=158518

Missing WebKit2 pieces (Requested by anttik on #webkit).

Reverted changeset:

"WebKit memory cache doesn't respect Vary header"
https://bugs.webkit.org/show_bug.cgi?id=71509
http://trac.webkit.org/changeset/201800

Location:
trunk/Source/WebCore
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r201800 r201801  
     12016-06-08  Commit Queue  <commit-queue@webkit.org>
     2
     3        Unreviewed, rolling out r201800.
     4        https://bugs.webkit.org/show_bug.cgi?id=158518
     5
     6        Missing WebKit2 pieces (Requested by anttik on #webkit).
     7
     8        Reverted changeset:
     9
     10        "WebKit memory cache doesn't respect Vary header"
     11        https://bugs.webkit.org/show_bug.cgi?id=71509
     12        http://trac.webkit.org/changeset/201800
     13
    1142016-06-06  Antti Koivisto  <antti@apple.com>
    215
  • trunk/Source/WebCore/loader/cache/CachedResource.cpp

    r201800 r201801  
    183183}
    184184
    185 static void addAdditionalRequestHeadersToRequest(ResourceRequest& request, const CachedResourceLoader& cachedResourceLoader)
     185void CachedResource::addAdditionalRequestHeaders(CachedResourceLoader& cachedResourceLoader)
    186186{
    187187    // Note: We skip the Content-Security-Policy check here because we check
     
    192192    String outgoingReferrer;
    193193    String outgoingOrigin;
    194     if (request.httpReferrer().isNull()) {
     194    if (m_resourceRequest.httpReferrer().isNull()) {
    195195        outgoingReferrer = frameLoader.outgoingReferrer();
    196196        outgoingOrigin = frameLoader.outgoingOrigin();
    197197    } else {
    198         outgoingReferrer = request.httpReferrer();
     198        outgoingReferrer = m_resourceRequest.httpReferrer();
    199199        outgoingOrigin = SecurityOrigin::createFromString(outgoingReferrer)->toString();
    200200    }
    201201
    202     auto referrerPolicy = cachedResourceLoader.document() ? cachedResourceLoader.document()->referrerPolicy() : ReferrerPolicy::Default;
    203     outgoingReferrer = SecurityPolicy::generateReferrerHeader(referrerPolicy, request.url(), outgoingReferrer);
     202    outgoingReferrer = SecurityPolicy::generateReferrerHeader(cachedResourceLoader.document()->referrerPolicy(), m_resourceRequest.url(), outgoingReferrer);
    204203    if (outgoingReferrer.isEmpty())
    205         request.clearHTTPReferrer();
     204        m_resourceRequest.clearHTTPReferrer();
    206205    else
    207         request.setHTTPReferrer(outgoingReferrer);
    208     FrameLoader::addHTTPOriginIfNeeded(request, outgoingOrigin);
    209 
    210     frameLoader.addExtraFieldsToSubresourceRequest(request);
    211 }
    212 
    213 void CachedResource::addAdditionalRequestHeaders(CachedResourceLoader& cachedResourceLoader)
    214 {
    215     addAdditionalRequestHeadersToRequest(m_resourceRequest, cachedResourceLoader);
     206        m_resourceRequest.setHTTPReferrer(outgoingReferrer);
     207    FrameLoader::addHTTPOriginIfNeeded(m_resourceRequest, outgoingOrigin);
     208
     209    frameLoader.addExtraFieldsToSubresourceRequest(m_resourceRequest);
    216210}
    217211
     
    424418    m_response.setType(m_responseType);
    425419    m_response.setRedirected(m_redirectChainCacheStatus.status != RedirectChainCacheStatus::NoRedirection);
    426 
    427     m_varyingHeaderValues = collectVaryingRequestHeaders(m_resourceRequest, m_response, m_sessionID);
    428420}
    429421
     
    774766}
    775767
    776 bool CachedResource::varyHeaderValuesMatch(const ResourceRequest& request, const CachedResourceLoader& cachedResourceLoader)
    777 {
    778     if (m_varyingHeaderValues.isEmpty())
    779         return true;
    780 
    781     ResourceRequest requestWithFullHeaders(request);
    782     addAdditionalRequestHeadersToRequest(requestWithFullHeaders, cachedResourceLoader);
    783 
    784     return verifyVaryingRequestHeaders(m_varyingHeaderValues, requestWithFullHeaders, m_sessionID);
    785 }
    786 
    787768unsigned CachedResource::overheadSize() const
    788769{
  • trunk/Source/WebCore/loader/cache/CachedResource.h

    r201800 r201801  
    243243    bool redirectChainAllowsReuse(ReuseExpiredRedirectionOrNot) const;
    244244
    245     bool varyHeaderValuesMatch(const ResourceRequest&, const CachedResourceLoader&);
    246 
    247245    bool isCacheValidator() const { return m_resourceToRevalidate; }
    248246    CachedResource* resourceToRevalidate() const { return m_resourceToRevalidate; }
     
    357355    RedirectChainCacheStatus m_redirectChainCacheStatus;
    358356
    359     Vector<std::pair<String, String>> m_varyingHeaderValues;
    360 
    361357    unsigned long m_identifierForLoadWithoutResourceLoader { 0 };
    362358};
  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

    r201800 r201801  
    754754    }
    755755
    756     if (!existingResource->varyHeaderValuesMatch(request, *this))
    757         return Reload;
    758 
    759756    auto* textDecoder = existingResource->textResourceDecoder();
    760757    if (textDecoder && !textDecoder->hasEqualEncodingForCharset(cachedResourceRequest.charset()))
  • trunk/Source/WebCore/platform/network/CacheValidation.cpp

    r201800 r201801  
    2828
    2929#include "HTTPHeaderMap.h"
    30 #include "NetworkStorageSession.h"
    31 #include "PlatformCookieJar.h"
    32 #include "ResourceRequest.h"
    3330#include "ResourceResponse.h"
    3431#include <wtf/CurrentTime.h>
     
    330327}
    331328
    332 static String headerValueForVary(SessionID sessionID, const ResourceRequest& request, const String& headerName)
    333 {
    334     // Explicit handling for cookies is needed because they are added magically by the networking layer.
    335     // FIXME: The value might have changed between making the request and retrieving the cookie here.
    336     // We could fetch the cookie when making the request but that seems overkill as the case is very rare and it
    337     // is a blocking operation. This should be sufficient to cover reasonable cases.
    338     if (headerName == httpHeaderNameString(HTTPHeaderName::Cookie)) {
    339         if (sessionID != SessionID::defaultSessionID()) {
    340             // FIXME: Don't know how to get the cookie. There should be a global way to get NetworkStorageSession from sessionID.
    341             return "";
    342         }
    343         return cookieRequestHeaderFieldValue(NetworkStorageSession::defaultStorageSession(), request.firstPartyForCookies(), request.url());
    344     }
    345     return request.httpHeaderField(headerName);
    346 }
    347 
    348 Vector<std::pair<String, String>> collectVaryingRequestHeaders(const WebCore::ResourceRequest& request, const WebCore::ResourceResponse& response, SessionID sessionID)
    349 {
    350     String varyValue = response.httpHeaderField(WebCore::HTTPHeaderName::Vary);
    351     if (varyValue.isEmpty())
    352         return { };
    353     Vector<String> varyingHeaderNames;
    354     varyValue.split(',', /*allowEmptyEntries*/ false, varyingHeaderNames);
    355     Vector<std::pair<String, String>> varyingRequestHeaders;
    356     varyingRequestHeaders.reserveCapacity(varyingHeaderNames.size());
    357     for (auto& varyHeaderName : varyingHeaderNames) {
    358         String headerName = varyHeaderName.stripWhiteSpace();
    359         String headerValue = headerValueForVary(sessionID, request, headerName);
    360         varyingRequestHeaders.append(std::make_pair(headerName, headerValue));
    361     }
    362     return varyingRequestHeaders;
    363 }
    364 
    365 bool verifyVaryingRequestHeaders(const Vector<std::pair<String, String>>& varyingRequestHeaders, const WebCore::ResourceRequest& request, SessionID sessionID)
    366 {
    367     for (auto& varyingRequestHeader : varyingRequestHeaders) {
    368         // FIXME: Vary: * in response would ideally trigger a cache delete instead of a store.
    369         if (varyingRequestHeader.first == "*")
    370             return false;
    371         if (sessionID != SessionID::defaultSessionID() && varyingRequestHeader.first == httpHeaderNameString(HTTPHeaderName::Cookie)) {
    372             // FIXME: See the comment in headerValueForVary.
    373             return false;
    374         }
    375         String headerValue = headerValueForVary(sessionID, request, varyingRequestHeader.first);
    376         if (headerValue != varyingRequestHeader.second)
    377             return false;
    378     }
    379     return true;
    380 }
    381 
    382 }
     329}
  • trunk/Source/WebCore/platform/network/CacheValidation.h

    r201800 r201801  
    2828
    2929#include "PlatformExportMacros.h"
    30 #include "SessionID.h"
    3130#include <wtf/Optional.h>
    32 #include <wtf/Vector.h>
    33 #include <wtf/text/WTFString.h>
    3431
    3532namespace WebCore {
    3633
    3734class HTTPHeaderMap;
    38 class ResourceRequest;
    3935class ResourceResponse;
    4036
     
    7066WEBCORE_EXPORT CacheControlDirectives parseCacheControlDirectives(const HTTPHeaderMap&);
    7167
    72 WEBCORE_EXPORT Vector<std::pair<String, String>> collectVaryingRequestHeaders(const ResourceRequest&, const ResourceResponse&, SessionID = SessionID::defaultSessionID());
    73 WEBCORE_EXPORT bool verifyVaryingRequestHeaders(const Vector<std::pair<String, String>>& varyingRequestHeaders, const ResourceRequest&, SessionID = SessionID::defaultSessionID());
    74 
    7568}
    7669
Note: See TracChangeset for help on using the changeset viewer.