Changeset 141981 in webkit


Ignore:
Timestamp:
Feb 6, 2013 3:24:03 AM (11 years ago)
Author:
commit-queue@webkit.org
Message:

Take referrer policy into account when clearing the referrer header
https://bugs.webkit.org/show_bug.cgi?id=86000

Patch by Marja Hölttä <marja@chromium.org> on 2013-02-06
Reviewed by Alexey Proskuryakov.

Source/WebCore:

The referrer should only be cleared when doing a https -> http redirect,
if the policy is "default". Otherwise the referrer should be left intact.

In order to do that, added a function for checking the policy in
NetworkingContext, and stored the NetworkingContext in ResourceHandle
(like some ports already did).

No new tests (unskipped old tests).

  • loader/FrameNetworkingContext.h:

(WebCore::FrameNetworkingContext::shouldClearReferrerOnHTTPSToHTTPRedirect):
(FrameNetworkingContext):

  • platform/network/BlobResourceHandle.cpp:

(WebCore::BlobResourceHandle::BlobResourceHandle):

  • platform/network/NetworkingContext.h:

(NetworkingContext):

  • platform/network/ResourceHandle.cpp:

(WebCore::ResourceHandle::ResourceHandle):
(WebCore::ResourceHandle::create):
(WebCore::ResourceHandle::context):
(WebCore):

  • platform/network/ResourceHandle.h:

(ResourceHandle):

  • platform/network/ResourceHandleInternal.h:

(WebCore::ResourceHandleInternal::ResourceHandleInternal):
(ResourceHandleInternal):

  • platform/network/blackberry/ResourceHandleBlackBerry.cpp:

(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::loadResourceSynchronously):

  • platform/network/cf/ResourceHandleCFNet.cpp:

(WebCore::willSendRequest):
(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::loadResourceSynchronously):

  • platform/network/chromium/ResourceHandle.cpp:

(WebCore::ResourceHandleInternal::ResourceHandleInternal):
(WebCore::ResourceHandle::ResourceHandle):
(WebCore::ResourceHandle::create):
(WebCore::ResourceHandle::context):
(WebCore):
(WebCore::ResourceHandle::start):

  • platform/network/chromium/ResourceHandleInternal.h:

(WebCore):
(ResourceHandleInternal):
(WebCore::ResourceHandleInternal::context):

  • platform/network/curl/ResourceHandleCurl.cpp:

(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::loadResourceSynchronously):

  • platform/network/mac/ResourceHandleMac.mm:

(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::loadResourceSynchronously):
(-[WebCoreResourceHandleAsDelegate connection:willSendRequest:redirectResponse:]):

  • platform/network/qt/QNetworkReplyHandler.cpp:

(WebCore::QNetworkReplyHandler::redirect):

  • platform/network/qt/ResourceHandleQt.cpp:

(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::loadResourceSynchronously):

  • platform/network/soup/ResourceHandleSoup.cpp:

(WebCore::doRedirect):
(WebCore::ResourceHandle::start):

  • platform/network/win/ResourceHandleWin.cpp:

(WebCore::ResourceHandle::start):
(WebCore::ResourceHandle::loadResourceSynchronously):

Source/WebKit2:

The referrer should only be cleared when doing a https -> http redirect,
if the policy is "default". Otherwise the referrer should be left intact.

  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::NetworkResourceLoader::start):

  • NetworkProcess/SchedulableLoader.cpp:

(WebKit::SchedulableLoader::SchedulableLoader):

  • NetworkProcess/SchedulableLoader.h:

(WebKit::SchedulableLoader::shouldClearReferrerOnHTTPSToHTTPRedirect):
(SchedulableLoader):

  • NetworkProcess/SyncNetworkResourceLoader.cpp:

(WebKit::SyncNetworkResourceLoader::start):

  • NetworkProcess/mac/RemoteNetworkingContext.h:

(WebKit::RemoteNetworkingContext::create):
(RemoteNetworkingContext):

  • NetworkProcess/mac/RemoteNetworkingContext.mm:

(WebKit::RemoteNetworkingContext::shouldClearReferrerOnHTTPSToHTTPRedirect):
(WebKit):
(WebKit::RemoteNetworkingContext::RemoteNetworkingContext):

  • Shared/Network/NetworkResourceLoadParameters.cpp:

(WebKit::NetworkResourceLoadParameters::NetworkResourceLoadParameters):
(WebKit::NetworkResourceLoadParameters::encode):
(WebKit::NetworkResourceLoadParameters::decode):

  • Shared/Network/NetworkResourceLoadParameters.h:

(NetworkResourceLoadParameters):
(WebKit::NetworkResourceLoadParameters::shouldClearReferrerOnHTTPSToHTTPRedirect):

  • WebProcess/Network/WebResourceLoadScheduler.cpp:

(WebKit::WebResourceLoadScheduler::scheduleSubresourceLoad):
(WebKit::WebResourceLoadScheduler::schedulePluginStreamLoad):
(WebKit::WebResourceLoadScheduler::scheduleLoad):

  • WebProcess/Network/WebResourceLoadScheduler.h:

(WebResourceLoadScheduler):

  • WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:

(WebKit::WebPlatformStrategies::loadResourceSynchronously):

LayoutTests:

Unskip http/tests/security/referrer-policy-redirect-link.html

Skipping the tests on wk2, because other referrer policy tests are
skipped, too ( https://bugs.webkit.org/show_bug.cgi?id=73913 ).

  • platform/gtk/TestExpectations:
  • platform/mac/TestExpectations:
  • platform/qt/TestExpectations:
  • platform/win/TestExpectations:
  • platform/wk2/TestExpectations:
Location:
trunk
Files:
35 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r141980 r141981  
     12013-02-06  Marja Hölttä  <marja@chromium.org>
     2
     3        Take referrer policy into account when clearing the referrer header
     4        https://bugs.webkit.org/show_bug.cgi?id=86000
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        Unskip http/tests/security/referrer-policy-redirect-link.html
     9
     10        Skipping the tests on wk2, because other referrer policy tests are
     11        skipped, too ( https://bugs.webkit.org/show_bug.cgi?id=73913 ).
     12
     13        * platform/gtk/TestExpectations:
     14        * platform/mac/TestExpectations:
     15        * platform/qt/TestExpectations:
     16        * platform/win/TestExpectations:
     17        * platform/wk2/TestExpectations:
     18
    1192013-02-06  Allan Sandfeld Jensen  <allan.jensen@digia.com>
    220
  • trunk/LayoutTests/platform/gtk/TestExpectations

    r141974 r141981  
    12461246webkit.org/b/85969 http/tests/loading/post-in-iframe-with-back-navigation.html [ Failure ]
    12471247
    1248 # Started failing after it was added in r116563
    1249 webkit.org/b/86061 http/tests/security/referrer-policy-redirect-link.html [ Failure ]
    1250 
    12511248webkit.org/b/85308 [ Release ] ietestcenter/css3/valuesandunits/units-000.htm [ ImageOnlyFailure ]
    12521249
  • trunk/LayoutTests/platform/mac/TestExpectations

    r141801 r141981  
    773773http/tests/loading/post-in-iframe-with-back-navigation.html
    774774
    775 # https://bugs.webkit.org/show_bug.cgi?id=86000
    776 http/tests/security/referrer-policy-redirect-link.html
    777 
    778775# Inspector only supports evaluation in content script world with v8, see https://bugs.webkit.org/show_bug.cgi?id=85709
    779776inspector/extensions/extensions-eval-content-script.html
  • trunk/LayoutTests/platform/qt/TestExpectations

    r141980 r141981  
    18891889security/block-test.html
    18901890
    1891 # https://bugs.webkit.org/show_bug.cgi?id=86000
    1892 http/tests/security/referrer-policy-redirect-link.html
    1893 
    18941891# ============================================================================= #
    18951892# failing tables tests
  • trunk/LayoutTests/platform/win/TestExpectations

    r141933 r141981  
    18531853# https://bugs.webkit.org/show_bug.cgi?id=85689
    18541854fast/animation/request-animation-frame-disabled.html
    1855 
    1856 # https://bugs.webkit.org/show_bug.cgi?id=86000
    1857 http/tests/security/referrer-policy-redirect-link.html
    18581855
    18591856# Inspector only supports evaluation in content script world with v8, see https://bugs.webkit.org/show_bug.cgi?id=85709
  • trunk/LayoutTests/platform/wk2/TestExpectations

    r141802 r141981  
    314314http/tests/security/referrer-policy-https-origin.html
    315315http/tests/security/referrer-policy-redirect.html
     316http/tests/security/referrer-policy-redirect-link.html
    316317http/tests/security/referrer-policy-https-never.html
    317318http/tests/security/referrer-policy-https-default.html
     
    334335# autoZoomPageToFitWidth().
    335336inspector/styles/override-screen-size.html
    336 
    337 # The network stack unconditionally strips the header on transitions from
    338 # secure to insecure. It should take the referrer policy into account instead.
    339 # https://bugs.webkit.org/show_bug.cgi?id=86000
    340 http/tests/security/referrer-policy-redirect-link.html
    341337
    342338# css3-conditionals support is not yet enabled.
  • trunk/Source/WebCore/ChangeLog

    r141979 r141981  
     12013-02-06  Marja Hölttä  <marja@chromium.org>
     2
     3        Take referrer policy into account when clearing the referrer header
     4        https://bugs.webkit.org/show_bug.cgi?id=86000
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        The referrer should only be cleared when doing a https -> http redirect,
     9        if the policy is "default". Otherwise the referrer should be left intact.
     10
     11        In order to do that, added a function for checking the policy in
     12        NetworkingContext, and stored the NetworkingContext in ResourceHandle
     13        (like some ports already did).
     14
     15        No new tests (unskipped old tests).
     16
     17        * loader/FrameNetworkingContext.h:
     18        (WebCore::FrameNetworkingContext::shouldClearReferrerOnHTTPSToHTTPRedirect):
     19        (FrameNetworkingContext):
     20        * platform/network/BlobResourceHandle.cpp:
     21        (WebCore::BlobResourceHandle::BlobResourceHandle):
     22        * platform/network/NetworkingContext.h:
     23        (NetworkingContext):
     24        * platform/network/ResourceHandle.cpp:
     25        (WebCore::ResourceHandle::ResourceHandle):
     26        (WebCore::ResourceHandle::create):
     27        (WebCore::ResourceHandle::context):
     28        (WebCore):
     29        * platform/network/ResourceHandle.h:
     30        (ResourceHandle):
     31        * platform/network/ResourceHandleInternal.h:
     32        (WebCore::ResourceHandleInternal::ResourceHandleInternal):
     33        (ResourceHandleInternal):
     34        * platform/network/blackberry/ResourceHandleBlackBerry.cpp:
     35        (WebCore::ResourceHandle::start):
     36        (WebCore::ResourceHandle::loadResourceSynchronously):
     37        * platform/network/cf/ResourceHandleCFNet.cpp:
     38        (WebCore::willSendRequest):
     39        (WebCore::ResourceHandle::start):
     40        (WebCore::ResourceHandle::loadResourceSynchronously):
     41        * platform/network/chromium/ResourceHandle.cpp:
     42        (WebCore::ResourceHandleInternal::ResourceHandleInternal):
     43        (WebCore::ResourceHandle::ResourceHandle):
     44        (WebCore::ResourceHandle::create):
     45        (WebCore::ResourceHandle::context):
     46        (WebCore):
     47        (WebCore::ResourceHandle::start):
     48        * platform/network/chromium/ResourceHandleInternal.h:
     49        (WebCore):
     50        (ResourceHandleInternal):
     51        (WebCore::ResourceHandleInternal::context):
     52        * platform/network/curl/ResourceHandleCurl.cpp:
     53        (WebCore::ResourceHandle::start):
     54        (WebCore::ResourceHandle::loadResourceSynchronously):
     55        * platform/network/mac/ResourceHandleMac.mm:
     56        (WebCore::ResourceHandle::start):
     57        (WebCore::ResourceHandle::loadResourceSynchronously):
     58        (-[WebCoreResourceHandleAsDelegate connection:willSendRequest:redirectResponse:]):
     59        * platform/network/qt/QNetworkReplyHandler.cpp:
     60        (WebCore::QNetworkReplyHandler::redirect):
     61        * platform/network/qt/ResourceHandleQt.cpp:
     62        (WebCore::ResourceHandle::start):
     63        (WebCore::ResourceHandle::loadResourceSynchronously):
     64        * platform/network/soup/ResourceHandleSoup.cpp:
     65        (WebCore::doRedirect):
     66        (WebCore::ResourceHandle::start):
     67        * platform/network/win/ResourceHandleWin.cpp:
     68        (WebCore::ResourceHandle::start):
     69        (WebCore::ResourceHandle::loadResourceSynchronously):
     70
    1712013-02-06  Pavel Feldman  <pfeldman@chromium.org>
    272
  • trunk/Source/WebCore/loader/FrameNetworkingContext.h

    r134960 r141981  
    2121#define FrameNetworkingContext_h
    2222
     23#include "Document.h"
    2324#include "Frame.h"
    2425#include "NetworkingContext.h"
     26#include "ReferrerPolicy.h"
    2527
    2628namespace WebCore {
     
    3133    {
    3234        m_frame = 0;
     35    }
     36
     37    virtual bool shouldClearReferrerOnHTTPSToHTTPRedirect() const
     38    {
     39        return m_frame->document()->referrerPolicy() == ReferrerPolicyDefault;
    3340    }
    3441
  • trunk/Source/WebCore/platform/network/BlobResourceHandle.cpp

    r138413 r141981  
    4141#include "HTTPParsers.h"
    4242#include "KURL.h"
    43 #include "NetworkingContext.h"
    4443#include "ResourceError.h"
    4544#include "ResourceHandleClient.h"
     
    143142
    144143BlobResourceHandle::BlobResourceHandle(PassRefPtr<BlobStorageData> blobData, const ResourceRequest& request, ResourceHandleClient* client, bool async)
    145     : ResourceHandle(request, client, false, false)
     144    : ResourceHandle(0, request, client, false, false)
    146145    , m_blobData(blobData)
    147146    , m_async(async)
     
    637636
    638637#endif // ENABLE(BLOB)
    639 
  • trunk/Source/WebCore/platform/network/NetworkingContext.h

    r141749 r141981  
    6666    virtual bool isValid() const { return true; }
    6767
     68    virtual bool shouldClearReferrerOnHTTPSToHTTPRedirect() const = 0;
     69
    6870#if PLATFORM(CHROMIUM)
    6971    // FIXME: Wrap WebCookieJar into a NetworkStorageSession to make the code cross-platform.
  • trunk/Source/WebCore/platform/network/ResourceHandle.cpp

    r141684 r141981  
    5454}
    5555
    56 ResourceHandle::ResourceHandle(const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading, bool shouldContentSniff)
    57     : d(adoptPtr(new ResourceHandleInternal(this, request, client, defersLoading, shouldContentSniff && shouldContentSniffURL(request.url()))))
     56ResourceHandle::ResourceHandle(NetworkingContext* context, const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading, bool shouldContentSniff)
     57    : d(adoptPtr(new ResourceHandleInternal(this, context, request, client, defersLoading, shouldContentSniff && shouldContentSniffURL(request.url()))))
    5858{
    5959    if (!request.url().isValid()) {
     
    7575        return protocolMapItem->value(request, client);
    7676
    77     RefPtr<ResourceHandle> newHandle(adoptRef(new ResourceHandle(request, client, defersLoading, shouldContentSniff)));
     77    RefPtr<ResourceHandle> newHandle(adoptRef(new ResourceHandle(context, request, client, defersLoading, shouldContentSniff)));
    7878
    7979    if (newHandle->d->m_scheduledFailureType != NoFailure)
    8080        return newHandle.release();
    8181
    82     if (newHandle->start(context))
     82    if (newHandle->start())
    8383        return newHandle.release();
    8484
     
    129129}
    130130
     131NetworkingContext* ResourceHandle::context() const
     132{
     133    return d->m_context.get();
     134}
     135
    131136const String& ResourceHandle::lastHTTPMethod() const
    132137{
  • trunk/Source/WebCore/platform/network/ResourceHandle.h

    r141684 r141981  
    200200    void fireFailure(Timer<ResourceHandle>*);
    201201
     202    NetworkingContext* context() const;
     203
    202204    using RefCounted<ResourceHandle>::ref;
    203205    using RefCounted<ResourceHandle>::deref;
     
    215217
    216218protected:
    217     ResourceHandle(const ResourceRequest&, ResourceHandleClient*, bool defersLoading, bool shouldContentSniff);
     219    ResourceHandle(NetworkingContext*, const ResourceRequest&, ResourceHandleClient*, bool defersLoading, bool shouldContentSniff);
    218220
    219221private:
     
    228230    void scheduleFailure(FailureType);
    229231
    230     bool start(NetworkingContext*);
     232    bool start();
    231233
    232234    virtual void refAuthenticationClient() { ref(); }
  • trunk/Source/WebCore/platform/network/ResourceHandleInternal.h

    r141821 r141981  
    8484        WTF_MAKE_NONCOPYABLE(ResourceHandleInternal); WTF_MAKE_FAST_ALLOCATED;
    8585    public:
    86         ResourceHandleInternal(ResourceHandle* loader, const ResourceRequest& request, ResourceHandleClient* c, bool defersLoading, bool shouldContentSniff)
    87             : m_client(c)
     86        ResourceHandleInternal(ResourceHandle* loader, NetworkingContext* context, const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading, bool shouldContentSniff)
     87            : m_context(context)
     88            , m_client(client)
    8889            , m_firstRequest(request)
    8990            , m_lastHTTPMethod(request.httpMethod())
     
    139140
    140141        ResourceHandleClient* client() { return m_client; }
     142
     143        RefPtr<NetworkingContext> m_context;
    141144        ResourceHandleClient* m_client;
    142        
    143145        ResourceRequest m_firstRequest;
    144146        String m_lastHTTPMethod;
     
    205207        unsigned long m_bodySize;
    206208        unsigned long m_bodyDataSent;
    207         RefPtr<NetworkingContext> m_context;
    208209        SoupSession* soupSession();
    209210        int m_redirectCount;
     
    217218#if PLATFORM(QT)
    218219        QNetworkReplyHandler* m_job;
    219         RefPtr<NetworkingContext> m_context;
    220220#endif
    221221
  • trunk/Source/WebCore/platform/network/blackberry/ResourceHandleBlackBerry.cpp

    r138962 r141981  
    108108}
    109109
    110 bool ResourceHandle::start(NetworkingContext* context)
     110bool ResourceHandle::start()
    111111{
    112     if (!context || !context->isValid())
     112    if (!d->m_context || !d->m_context->isValid())
    113113        return false;
    114114
     
    157157    bool shouldContentSniff = false;
    158158
    159     RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, &syncLoader, defersLoading, shouldContentSniff));
     159    RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(context, request, &syncLoader, defersLoading, shouldContentSniff));
    160160    NetworkManager::instance()->startJob(playerId, handle, frame, defersLoading);
    161161
  • trunk/Source/WebCore/platform/network/cf/ResourceHandleCFNet.cpp

    r138962 r141981  
    185185
    186186    // Should not set Referer after a redirect from a secure resource to non-secure one.
    187     if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https"))
     187    if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https") && handle->context()->shouldClearReferrerOnHTTPSToHTTPRedirect())
    188188        request.clearHTTPReferrer();
    189189
     
    497497}
    498498
    499 bool ResourceHandle::start(NetworkingContext* context)
    500 {
    501     if (!context)
     499bool ResourceHandle::start()
     500{
     501    if (!d->m_context)
    502502        return false;
    503503
    504504    // If NetworkingContext is invalid then we are no longer attached to a Page,
    505505    // this must be an attempted load from an unload handler, so let's just block it.
    506     if (!context->isValid())
     506    if (!d->m_context->isValid())
    507507        return false;
    508508
    509     d->m_storageSession = context->storageSession().platformSession();
     509    d->m_storageSession = d->m_context->storageSession().platformSession();
    510510
    511511    bool shouldUseCredentialStorage = !client() || client()->shouldUseCredentialStorage(this);
    512512
    513     createCFURLConnection(shouldUseCredentialStorage, shouldRelaxThirdPartyCookiePolicy(context, firstRequest().url()), d->m_shouldContentSniff);
     513    createCFURLConnection(shouldUseCredentialStorage, shouldRelaxThirdPartyCookiePolicy(d->m_context.get(), firstRequest().url()), d->m_shouldContentSniff);
    514514
    515515#if PLATFORM(WIN)
     
    740740    client->setAllowStoredCredentials(storedCredentials == AllowStoredCredentials);
    741741
    742     RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, client.get(), false /*defersLoading*/, true /*shouldContentSniff*/));
     742    RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(context, request, client.get(), false /*defersLoading*/, true /*shouldContentSniff*/));
    743743
    744744    handle->d->m_storageSession = context->storageSession().platformSession();
     
    925925
    926926} // namespace WebCore
    927 
  • trunk/Source/WebCore/platform/network/chromium/ResourceHandle.cpp

    r141684 r141981  
    5353
    5454// ResourceHandleInternal -----------------------------------------------------
    55 ResourceHandleInternal::ResourceHandleInternal(const ResourceRequest& request, ResourceHandleClient* client)
    56     : m_request(request)
     55ResourceHandleInternal::ResourceHandleInternal(NetworkingContext* context, const ResourceRequest& request, ResourceHandleClient* client)
     56    : m_context(context)
     57    , m_request(request)
    5758    , m_owner(0)
    5859    , m_client(client)
     
    179180// ResourceHandle -------------------------------------------------------------
    180181
    181 ResourceHandle::ResourceHandle(const ResourceRequest& request,
    182                                ResourceHandleClient* client,
    183                                bool defersLoading,
    184                                bool shouldContentSniff)
    185     : d(adoptPtr(new ResourceHandleInternal(request, client)))
     182ResourceHandle::ResourceHandle(NetworkingContext* context, const ResourceRequest& request, ResourceHandleClient* client, bool defersLoading, bool shouldContentSniff)
     183    : d(adoptPtr(new ResourceHandleInternal(context, request, client)))
    186184{
    187185    d->setOwner(this);
     
    197195{
    198196    RefPtr<ResourceHandle> newHandle = adoptRef(new ResourceHandle(
    199         request, client, defersLoading, shouldContentSniff));
    200 
    201     if (newHandle->start(context))
     197        context, request, client, defersLoading, shouldContentSniff));
     198
     199    if (newHandle->start())
    202200        return newHandle.release();
    203201
     
    210208}
    211209
     210NetworkingContext* ResourceHandle::context() const
     211{
     212    return d->context();
     213}
     214
    212215ResourceHandleClient* ResourceHandle::client() const
    213216{
     
    225228}
    226229
    227 bool ResourceHandle::start(NetworkingContext* context)
    228 {
    229     if (!context)
     230bool ResourceHandle::start()
     231{
     232    if (!d->context())
    230233        return false;
    231234
  • trunk/Source/WebCore/platform/network/chromium/ResourceHandleInternal.h

    r141684 r141981  
    4040namespace WebCore {
    4141
     42class NetworkingContext;
    4243class ResourceHandle;
    4344class ResourceHandleClient;
     
    4546class ResourceHandleInternal : public WebKit::WebURLLoaderClient {
    4647public:
    47     ResourceHandleInternal(const ResourceRequest&, ResourceHandleClient*);
     48    ResourceHandleInternal(NetworkingContext*, const ResourceRequest&, ResourceHandleClient*);
    4849
    4950    virtual ~ResourceHandleInternal() { }
     
    8182    void setClient(ResourceHandleClient* client) { m_client = client; }
    8283    WebKit::WebURLLoader* loader() const { return m_loader.get(); }
     84    NetworkingContext* context() const { return m_context.get(); }
    8385
    8486    static ResourceHandleInternal* FromResourceHandle(ResourceHandle*);
    8587
    8688private:
     89    RefPtr<NetworkingContext> m_context;
    8790    ResourceRequest m_request;
    8891    ResourceHandle* m_owner;
  • trunk/Source/WebCore/platform/network/curl/ResourceHandleCurl.cpp

    r138962 r141981  
    9797}
    9898
    99 bool ResourceHandle::start(NetworkingContext* context)
     99bool ResourceHandle::start()
    100100{
    101101    // The frame could be null if the ResourceHandle is not associated to any
     
    104104    // load from an unload handler, so let's just block it.
    105105    // If both the frame and the page are not null the context is valid.
    106     if (context && !context->isValid())
     106    if (d->m_context && !d->m_context->isValid())
    107107        return false;
    108108
     
    176176{
    177177    WebCoreSynchronousLoader syncLoader;
    178     RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, &syncLoader, true, false));
     178    RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(context, request, &syncLoader, true, false));
    179179
    180180    ResourceHandleManager* manager = ResourceHandleManager::sharedInstance();
  • trunk/Source/WebCore/platform/network/mac/ResourceHandleMac.mm

    r138962 r141981  
    219219}
    220220
    221 bool ResourceHandle::start(NetworkingContext* context)
    222 {
    223     if (!context)
     221bool ResourceHandle::start()
     222{
     223    if (!d->m_context)
    224224        return false;
    225225
     
    228228    // If NetworkingContext is invalid then we are no longer attached to a Page,
    229229    // this must be an attempted load from an unload event handler, so let's just block it.
    230     if (!context->isValid())
     230    if (!d->m_context->isValid())
    231231        return false;
    232232
    233     d->m_storageSession = context->storageSession().platformSession();
     233    d->m_storageSession = d->m_context->storageSession().platformSession();
    234234
    235235    ASSERT(!d->m_proxy);
     
    239239    bool shouldUseCredentialStorage = !client() || client()->shouldUseCredentialStorage(this);
    240240
    241     d->m_needsSiteSpecificQuirks = context->needsSiteSpecificQuirks();
     241    d->m_needsSiteSpecificQuirks = d->m_context->needsSiteSpecificQuirks();
    242242
    243243    createNSURLConnection(
    244244        d->m_proxy.get(),
    245245        shouldUseCredentialStorage,
    246         shouldRelaxThirdPartyCookiePolicy(context, firstRequest().url()),
    247         d->m_shouldContentSniff || context->localFileContentSniffingEnabled());
     246        shouldRelaxThirdPartyCookiePolicy(d->m_context.get(), firstRequest().url()),
     247        d->m_shouldContentSniff || d->m_context->localFileContentSniffingEnabled());
    248248
    249249    bool scheduled = false;
    250     if (SchedulePairHashSet* scheduledPairs = context->scheduledRunLoopPairs()) {
     250    if (SchedulePairHashSet* scheduledPairs = d->m_context->scheduledRunLoopPairs()) {
    251251        SchedulePairHashSet::iterator end = scheduledPairs->end();
    252252        for (SchedulePairHashSet::iterator it = scheduledPairs->begin(); it != end; ++it) {
     
    258258    }
    259259
    260     if (NSOperationQueue *operationQueue = context->scheduledOperationQueue()) {
     260    if (NSOperationQueue *operationQueue = d->m_context->scheduledOperationQueue()) {
    261261        ASSERT(!scheduled);
    262262        [connection() setDelegateQueue:operationQueue];
     
    382382    client->setAllowStoredCredentials(storedCredentials == AllowStoredCredentials);
    383383
    384     RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, client.get(), false /*defersLoading*/, true /*shouldContentSniff*/));
     384    RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(context, request, client.get(), false /*defersLoading*/, true /*shouldContentSniff*/));
    385385
    386386    handle->d->m_storageSession = context->storageSession().platformSession();
     
    669669
    670670    // Should not set Referer after a redirect from a secure resource to non-secure one.
    671     if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https"))
     671    if (!request.url().protocolIs("https") && protocolIs(request.httpReferrer(), "https") && m_handle->context()->shouldClearReferrerOnHTTPSToHTTPRedirect())
    672672        request.clearHTTPReferrer();
    673673
  • trunk/Source/WebCore/platform/network/qt/QNetworkReplyHandler.cpp

    r138413 r141981  
    648648
    649649    // Should not set Referer after a redirect from a secure resource to non-secure one.
    650     if (!newRequest.url().protocolIs("https") && protocolIs(newRequest.httpReferrer(), "https"))
     650    if (!newRequest.url().protocolIs("https") && protocolIs(newRequest.httpReferrer(), "https") && m_resourceHandle->context()->shouldClearReferrerOnHTTPSToHTTPRedirect())
    651651        newRequest.clearHTTPReferrer();
    652652
  • trunk/Source/WebCore/platform/network/qt/ResourceHandleQt.cpp

    r138962 r141981  
    9191}
    9292
    93 bool ResourceHandle::start(NetworkingContext* context)
     93bool ResourceHandle::start()
    9494{
    9595    // If NetworkingContext is invalid then we are no longer attached to a Page,
    9696    // this must be an attempted load from an unload event handler, so let's just block it.
    97     if (context && !context->isValid())
     97    if (d->m_context && !d->m_context->isValid())
    9898        return false;
    9999
     
    107107    }
    108108
    109     getInternal()->m_context = context;
    110109    ResourceHandleInternal *d = getInternal();
    111110    d->m_job = new QNetworkReplyHandler(this, QNetworkReplyHandler::AsynchronousLoad, d->m_defersLoading);
     
    135134#endif
    136135    WebCoreSynchronousLoader syncLoader(error, response, data);
    137     RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(request, &syncLoader, true, false));
     136    RefPtr<ResourceHandle> handle = adoptRef(new ResourceHandle(context, request, &syncLoader, true, false));
    138137
    139138    ResourceHandleInternal* d = handle->getInternal();
     
    146145        d->m_firstRequest.setURL(urlWithCredentials);
    147146    }
    148     d->m_context = context;
    149147
    150148    // starting in deferred mode gives d->m_job the chance of being set before sending the request.
  • trunk/Source/WebCore/platform/network/soup/ResourceHandleSoup.cpp

    r141822 r141981  
    469469
    470470    // Should not set Referer after a redirect from a secure resource to non-secure one.
    471     if (!newURL.protocolIs("https") && protocolIs(request.httpReferrer(), "https"))
     471    if (!newURL.protocolIs("https") && protocolIs(request.httpReferrer(), "https") && handle->context()->shouldClearReferrerOnHTTPSToHTTPRedirect())
    472472        request.clearHTTPReferrer();
    473473
     
    10191019}
    10201020
    1021 bool ResourceHandle::start(NetworkingContext* context)
     1021bool ResourceHandle::start()
    10221022{
    10231023    ASSERT(!d->m_soupMessage);
     
    10281028    // load from an unload handler, so let's just block it.
    10291029    // If both the frame and the page are not null the context is valid.
    1030     if (context && !context->isValid())
     1030    if (d->m_context && !d->m_context->isValid())
    10311031        return false;
    1032 
    1033     // Used to set the keep track of custom SoupSessions for ports that support it (EFL).
    1034     d->m_context = context;
    10351032
    10361033    // Only allow the POST and GET methods for non-HTTP requests.
     
    10491046    }
    10501047
    1051     setSoupRequestInitiatingPageIDFromNetworkingContext(d->m_soupRequest.get(), context);
     1048    setSoupRequestInitiatingPageIDFromNetworkingContext(d->m_soupRequest.get(), d->m_context.get());
    10521049
    10531050    // Send the request only if it's not been explicitly deferred.
  • trunk/Source/WebCore/platform/network/win/ResourceHandleWin.cpp

    r138962 r141981  
    266266}
    267267
    268 bool ResourceHandle::start(NetworkingContext* context)
     268bool ResourceHandle::start()
    269269{
    270270    if (firstRequest().url().isLocalFile() || firstRequest().url().protocolIsData()) {
     
    278278
    279279    if (!d->m_internetHandle)
    280         d->m_internetHandle = asynchronousInternetHandle(context->userAgent());
     280        d->m_internetHandle = asynchronousInternetHandle(d->m_context->userAgent());
    281281
    282282    if (!d->m_internetHandle)
     
    420420
    421421    WebCoreSynchronousLoader syncLoader(error, response, data, request.httpUserAgent());
    422     ResourceHandle handle(request, &syncLoader, true, false);
     422    ResourceHandle handle(request, &syncLoader, true, false, context);
    423423
    424424    handle.setSynchronousInternetHandle(syncLoader.internetHandle());
    425     handle.start(context);
     425    handle.start();
    426426}
    427427
  • trunk/Source/WebKit2/ChangeLog

    r141978 r141981  
     12013-02-06  Marja Hölttä  <marja@chromium.org>
     2
     3        Take referrer policy into account when clearing the referrer header
     4        https://bugs.webkit.org/show_bug.cgi?id=86000
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        The referrer should only be cleared when doing a https -> http redirect,
     9        if the policy is "default". Otherwise the referrer should be left intact.
     10
     11        * NetworkProcess/NetworkResourceLoader.cpp:
     12        (WebKit::NetworkResourceLoader::start):
     13        * NetworkProcess/SchedulableLoader.cpp:
     14        (WebKit::SchedulableLoader::SchedulableLoader):
     15        * NetworkProcess/SchedulableLoader.h:
     16        (WebKit::SchedulableLoader::shouldClearReferrerOnHTTPSToHTTPRedirect):
     17        (SchedulableLoader):
     18        * NetworkProcess/SyncNetworkResourceLoader.cpp:
     19        (WebKit::SyncNetworkResourceLoader::start):
     20        * NetworkProcess/mac/RemoteNetworkingContext.h:
     21        (WebKit::RemoteNetworkingContext::create):
     22        (RemoteNetworkingContext):
     23        * NetworkProcess/mac/RemoteNetworkingContext.mm:
     24        (WebKit::RemoteNetworkingContext::shouldClearReferrerOnHTTPSToHTTPRedirect):
     25        (WebKit):
     26        (WebKit::RemoteNetworkingContext::RemoteNetworkingContext):
     27        * Shared/Network/NetworkResourceLoadParameters.cpp:
     28        (WebKit::NetworkResourceLoadParameters::NetworkResourceLoadParameters):
     29        (WebKit::NetworkResourceLoadParameters::encode):
     30        (WebKit::NetworkResourceLoadParameters::decode):
     31        * Shared/Network/NetworkResourceLoadParameters.h:
     32        (NetworkResourceLoadParameters):
     33        (WebKit::NetworkResourceLoadParameters::shouldClearReferrerOnHTTPSToHTTPRedirect):
     34        * WebProcess/Network/WebResourceLoadScheduler.cpp:
     35        (WebKit::WebResourceLoadScheduler::scheduleSubresourceLoad):
     36        (WebKit::WebResourceLoadScheduler::schedulePluginStreamLoad):
     37        (WebKit::WebResourceLoadScheduler::scheduleLoad):
     38        * WebProcess/Network/WebResourceLoadScheduler.h:
     39        (WebResourceLoadScheduler):
     40        * WebProcess/WebCoreSupport/WebPlatformStrategies.cpp:
     41        (WebKit::WebPlatformStrategies::loadResourceSynchronously):
     42
    1432013-02-06  Mikhail Pozdnyakov  <mikhail.pozdnyakov@intel.com>
    244
  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

    r140921 r141981  
    7979   
    8080    // FIXME (NetworkProcess): Create RemoteNetworkingContext with actual settings.
    81     m_networkingContext = RemoteNetworkingContext::create(false, false, inPrivateBrowsingMode());
     81    m_networkingContext = RemoteNetworkingContext::create(false, false, inPrivateBrowsingMode(), shouldClearReferrerOnHTTPSToHTTPRedirect());
    8282
    8383    consumeSandboxExtensions();
  • trunk/Source/WebKit2/NetworkProcess/SchedulableLoader.cpp

    r140874 r141981  
    4141    , m_inPrivateBrowsingMode(parameters.inPrivateBrowsingMode())
    4242    , m_connection(connection)
     43    , m_shouldClearReferrerOnHTTPSToHTTPRedirect(parameters.shouldClearReferrerOnHTTPSToHTTPRedirect())
    4344{
    4445    for (size_t i = 0, count = parameters.requestBodySandboxExtensions().size(); i < count; ++i) {
  • trunk/Source/WebKit2/NetworkProcess/SchedulableLoader.h

    r140874 r141981  
    6666    void invalidateSandboxExtensions();
    6767
     68    bool shouldClearReferrerOnHTTPSToHTTPRedirect() const { return m_shouldClearReferrerOnHTTPSToHTTPRedirect; }
     69
    6870private:
    6971    ResourceLoadIdentifier m_identifier;
     
    8284   
    8385    RefPtr<HostRecord> m_hostRecord;
     86
     87    bool m_shouldClearReferrerOnHTTPSToHTTPRedirect;
    8488};
    8589
  • trunk/Source/WebKit2/NetworkProcess/SyncNetworkResourceLoader.cpp

    r140843 r141981  
    6060   
    6161    // FIXME (NetworkProcess): Create RemoteNetworkingContext with actual settings.
    62     RefPtr<RemoteNetworkingContext> networkingContext = RemoteNetworkingContext::create(false, false, inPrivateBrowsingMode());
     62    RefPtr<RemoteNetworkingContext> networkingContext = RemoteNetworkingContext::create(false, false, inPrivateBrowsingMode(), shouldClearReferrerOnHTTPSToHTTPRedirect());
    6363
    6464    consumeSandboxExtensions();
  • trunk/Source/WebKit2/NetworkProcess/mac/RemoteNetworkingContext.h

    r138413 r141981  
    3333class RemoteNetworkingContext : public WebCore::NetworkingContext {
    3434public:
    35     static PassRefPtr<RemoteNetworkingContext> create(bool needsSiteSpecificQuirks, bool localFileContentSniffingEnabled, bool privateBrowsingEnabled)
     35    static PassRefPtr<RemoteNetworkingContext> create(bool needsSiteSpecificQuirks, bool localFileContentSniffingEnabled, bool privateBrowsingEnabled, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
    3636    {
    37         return adoptRef(new RemoteNetworkingContext(needsSiteSpecificQuirks, localFileContentSniffingEnabled, privateBrowsingEnabled));
     37        return adoptRef(new RemoteNetworkingContext(needsSiteSpecificQuirks, localFileContentSniffingEnabled, privateBrowsingEnabled, shouldClearReferrerOnHTTPSToHTTPRedirect));
    3838    }
    3939    virtual ~RemoteNetworkingContext();
     
    4545    static WebCore::NetworkStorageSession& privateBrowsingSession(); // Can only be called when the session exists.
    4646
     47    virtual bool shouldClearReferrerOnHTTPSToHTTPRedirect() const OVERRIDE;
     48
    4749private:
    48     RemoteNetworkingContext(bool needsSiteSpecificQuirks, bool localFileContentSniffingEnabled, bool privateBrowsingEnabled);
     50    RemoteNetworkingContext(bool needsSiteSpecificQuirks, bool localFileContentSniffingEnabled, bool privateBrowsingEnabled, bool m_shouldClearReferrerOnHTTPSToHTTPRedirect);
    4951
    5052    virtual bool isValid() const OVERRIDE;
     
    5961    bool m_localFileContentSniffingEnabled;
    6062    bool m_privateBrowsingEnabled;
     63    bool m_shouldClearReferrerOnHTTPSToHTTPRedirect;
    6164};
    6265
  • trunk/Source/WebKit2/NetworkProcess/mac/RemoteNetworkingContext.mm

    r138413 r141981  
    4343}
    4444
    45 RemoteNetworkingContext::RemoteNetworkingContext(bool needsSiteSpecificQuirks, bool localFileContentSniffingEnabled, bool privateBrowsingEnabled)
     45bool RemoteNetworkingContext::shouldClearReferrerOnHTTPSToHTTPRedirect() const
     46{
     47    return m_shouldClearReferrerOnHTTPSToHTTPRedirect;
     48}
     49
     50RemoteNetworkingContext::RemoteNetworkingContext(bool needsSiteSpecificQuirks, bool localFileContentSniffingEnabled, bool privateBrowsingEnabled, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
    4651    : m_needsSiteSpecificQuirks(needsSiteSpecificQuirks)
    4752    , m_localFileContentSniffingEnabled(localFileContentSniffingEnabled)
    4853    , m_privateBrowsingEnabled(privateBrowsingEnabled)
     54    , m_shouldClearReferrerOnHTTPSToHTTPRedirect(shouldClearReferrerOnHTTPSToHTTPRedirect)
    4955{
    5056}
  • trunk/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.cpp

    r141619 r141981  
    4646    , m_allowStoredCredentials(DoNotAllowStoredCredentials)
    4747    , m_inPrivateBrowsingMode(false)
     48    , m_shouldClearReferrerOnHTTPSToHTTPRedirect(true)
    4849{
    4950}
    5051
    51 NetworkResourceLoadParameters::NetworkResourceLoadParameters(ResourceLoadIdentifier identifier, uint64_t webPageID, uint64_t webFrameID, const ResourceRequest& request, ResourceLoadPriority priority, ContentSniffingPolicy contentSniffingPolicy, StoredCredentials allowStoredCredentials, bool inPrivateBrowsingMode)
     52NetworkResourceLoadParameters::NetworkResourceLoadParameters(ResourceLoadIdentifier identifier, uint64_t webPageID, uint64_t webFrameID, const ResourceRequest& request, ResourceLoadPriority priority, ContentSniffingPolicy contentSniffingPolicy, StoredCredentials allowStoredCredentials, bool inPrivateBrowsingMode, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
    5253    : m_identifier(identifier)
    5354    , m_webPageID(webPageID)
     
    5859    , m_allowStoredCredentials(allowStoredCredentials)
    5960    , m_inPrivateBrowsingMode(inPrivateBrowsingMode)
     61    , m_shouldClearReferrerOnHTTPSToHTTPRedirect(shouldClearReferrerOnHTTPSToHTTPRedirect)
    6062{
    6163}
     
    104106    encoder.encodeEnum(m_allowStoredCredentials);
    105107    encoder.encode(m_inPrivateBrowsingMode);
     108    encoder.encode(m_shouldClearReferrerOnHTTPSToHTTPRedirect);
    106109}
    107110
     
    148151    if (!decoder.decode(result.m_inPrivateBrowsingMode))
    149152        return false;
     153    if (!decoder.decode(result.m_shouldClearReferrerOnHTTPSToHTTPRedirect))
     154        return false;
    150155
    151156    return true;
  • trunk/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.h

    r141619 r141981  
    4646public:
    4747    NetworkResourceLoadParameters();
    48     NetworkResourceLoadParameters(ResourceLoadIdentifier, uint64_t webPageID, uint64_t webFrameID, const WebCore::ResourceRequest&, WebCore::ResourceLoadPriority, WebCore::ContentSniffingPolicy, WebCore::StoredCredentials, bool inPrivateBrowsingMode);
     48    NetworkResourceLoadParameters(ResourceLoadIdentifier, uint64_t webPageID, uint64_t webFrameID, const WebCore::ResourceRequest&, WebCore::ResourceLoadPriority, WebCore::ContentSniffingPolicy, WebCore::StoredCredentials, bool inPrivateBrowsingMode, bool shouldClearReferrerOnHTTPSToHTTPRedirect);
    4949
    5050    void encode(CoreIPC::ArgumentEncoder&) const;
     
    6161    WebCore::StoredCredentials allowStoredCredentials() const { return m_allowStoredCredentials; }
    6262    bool inPrivateBrowsingMode() const { return m_inPrivateBrowsingMode; }
     63    bool shouldClearReferrerOnHTTPSToHTTPRedirect() const { return m_shouldClearReferrerOnHTTPSToHTTPRedirect; }
    6364
    6465private:
     
    7374    WebCore::StoredCredentials m_allowStoredCredentials;
    7475    bool m_inPrivateBrowsingMode;
     76    bool m_shouldClearReferrerOnHTTPSToHTTPRedirect;
    7577};
    7678
  • trunk/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.cpp

    r141824 r141981  
    3838#include "WebProcess.h"
    3939#include "WebResourceLoader.h"
     40#include <WebCore/Document.h>
    4041#include <WebCore/DocumentLoader.h>
    4142#include <WebCore/Frame.h>
    4243#include <WebCore/FrameLoader.h>
    4344#include <WebCore/NetscapePlugInStreamLoader.h>
     45#include <WebCore/ReferrerPolicy.h>
    4446#include <WebCore/ResourceBuffer.h>
    4547#include <WebCore/ResourceLoader.h>
     
    6870    RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, resource, request, options);
    6971    if (loader)
    70         scheduleLoad(loader.get(), priority);
     72        scheduleLoad(loader.get(), priority, frame->document()->referrerPolicy() == ReferrerPolicyDefault);
    7173    return loader.release();
    7274}
     
    7678    RefPtr<NetscapePlugInStreamLoader> loader = NetscapePlugInStreamLoader::create(frame, client, request);
    7779    if (loader)
    78         scheduleLoad(loader.get(), ResourceLoadPriorityLow);
     80        scheduleLoad(loader.get(), ResourceLoadPriorityLow, frame->document()->referrerPolicy() == ReferrerPolicyDefault);
    7981    return loader.release();
    8082}
    8183
    82 void WebResourceLoadScheduler::scheduleLoad(ResourceLoader* resourceLoader, ResourceLoadPriority priority)
     84void WebResourceLoadScheduler::scheduleLoad(ResourceLoader* resourceLoader, ResourceLoadPriority priority, bool shouldClearReferrerOnHTTPSToHTTPRedirect)
    8385{
    8486    ASSERT(resourceLoader);
     
    106108    WebPage* webPage = webFrame->page();
    107109
    108     NetworkResourceLoadParameters loadParameters(identifier, webPage->pageID(), webFrame->frameID(), resourceLoader->request(), priority, contentSniffingPolicy, allowStoredCredentials, privateBrowsingEnabled);
     110    NetworkResourceLoadParameters loadParameters(identifier, webPage->pageID(), webFrame->frameID(), resourceLoader->request(), priority, contentSniffingPolicy, allowStoredCredentials, privateBrowsingEnabled, shouldClearReferrerOnHTTPSToHTTPRedirect);
    109111    if (!WebProcess::shared().networkConnection()->connection()->send(Messages::NetworkConnectionToWebProcess::ScheduleResourceLoad(loadParameters), 0)) {
    110112        // We probably failed to schedule this load with the NetworkProcess because it had crashed.
  • trunk/Source/WebKit2/WebProcess/Network/WebResourceLoadScheduler.h

    r141824 r141981  
    6464
    6565private:
    66     void scheduleLoad(WebCore::ResourceLoader*, WebCore::ResourceLoadPriority);
     66    void scheduleLoad(WebCore::ResourceLoader*, WebCore::ResourceLoadPriority, bool shouldClearReferrerOnHTTPSToHTTPRedirect);
    6767    void scheduleInternallyFailedLoad(WebCore::ResourceLoader*);
    6868    void internallyFailedLoadTimerFired();
  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/WebPlatformStrategies.cpp

    r141017 r141981  
    235235    CoreIPC::DataReference dataReference;
    236236
    237     NetworkResourceLoadParameters loadParameters(resourceLoadIdentifier, 0, 0, request, ResourceLoadPriorityHighest, SniffContent, storedCredentials, context->storageSession().isPrivateBrowsingSession());
     237    NetworkResourceLoadParameters loadParameters(resourceLoadIdentifier, 0, 0, request, ResourceLoadPriorityHighest, SniffContent, storedCredentials, context->storageSession().isPrivateBrowsingSession(), context->shouldClearReferrerOnHTTPSToHTTPRedirect());
    238238    if (!WebProcess::shared().networkConnection()->connection()->sendSync(Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad(loadParameters), Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::Reply(error, response, dataReference), 0)) {
    239239        response = ResourceResponse();
Note: See TracChangeset for help on using the changeset viewer.