Changeset 173468 in webkit


Ignore:
Timestamp:
Sep 10, 2014, 9:35:00 AM (11 years ago)
Author:
Antti Koivisto
Message:

NetworkResourceLoader cleanups
​https://bugs.webkit.org/show_bug.cgi?id=136701

Reviewed by Darin Adler.

After smashing NetworkResourceLoader together with the clients it can be made nicer.

  • NetworkProcess/NetworkResourceLoadScheduler.cpp:

(WebKit::NetworkResourceLoadScheduler::scheduleLoader):
(WebKit::NetworkResourceLoadScheduler::removeLoader):

  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::NetworkResourceLoader::SynchronousLoadData::SynchronousLoadData):

The original request is now part of the loader.

(WebKit::sendReplyToSynchronousRequest):
(WebKit::NetworkResourceLoader::NetworkResourceLoader):

Instead of copying everything out from NetworkResourceLoadParameters just include the whole thing as a const field.
SanboxExtension construction moves to NetworkResourceLoadParameters::decode()
Stuff that is related to starting the load moves to start().

(WebKit::NetworkResourceLoader::~NetworkResourceLoader):
(WebKit::NetworkResourceLoader::start):
(WebKit::NetworkResourceLoader::setDefersLoading):

Eliminate m_deferredRequest since we now always remember the original request.

(WebKit::NetworkResourceLoader::cleanup):
(WebKit::NetworkResourceLoader::didConvertHandleToDownload):
(WebKit::NetworkResourceLoader::abort):
(WebKit::NetworkResourceLoader::didReceiveResponseAsync):
(WebKit::NetworkResourceLoader::didFail):
(WebKit::NetworkResourceLoader::willSendRequestAsync):
(WebKit::NetworkResourceLoader::continueWillSendRequest):

Eliminate unnecessary m_suggestedRequestForWillSendRequest.

(WebKit::NetworkResourceLoader::wasBlocked):
(WebKit::NetworkResourceLoader::cannotShowURL):
(WebKit::NetworkResourceLoader::shouldUseCredentialStorage):
(WebKit::NetworkResourceLoader::didReceiveAuthenticationChallenge):
(WebKit::NetworkResourceLoader::receivedCancellation):
(WebKit::NetworkResourceLoader::startBufferingTimerIfNeeded):
(WebKit::NetworkResourceLoader::consumeSandboxExtensions):
(WebKit::NetworkResourceLoader::invalidateSandboxExtensions):
(WebKit::NetworkResourceLoader::sendAbortingOnFailure):

  • NetworkProcess/NetworkResourceLoader.h:

(WebKit::NetworkResourceLoader::originalRequest):
(WebKit::NetworkResourceLoader::currentRequest):
(WebKit::NetworkResourceLoader::sessionID):
(WebKit::NetworkResourceLoader::defersLoading):
(WebKit::NetworkResourceLoader::isLoadingMainResource):
(WebKit::NetworkResourceLoader::request): Deleted.
(WebKit::NetworkResourceLoader::sendAbortingOnFailure): Deleted.

Made private and moved to cpp.

  • NetworkProcess/mac/NetworkDiskCacheMonitor.mm:

(WebKit::NetworkDiskCacheMonitor::NetworkDiskCacheMonitor):

Use original request instead of the current one. This might fix a bug where we didn't use file backing over redirects.

  • Shared/Network/NetworkResourceLoadParameters.cpp:

(WebKit::NetworkResourceLoadParameters::decode):

Decode to SanboxExtensions to the actual type rather than a handle.

  • Shared/Network/NetworkResourceLoadParameters.h:
Location:
trunk/Source/WebKit2
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit2/ChangeLog

    r173456 r173468  
     12014-09-10  Antti Koivisto  <antti@apple.com>
     2
     3        NetworkResourceLoader cleanups
     4        https://bugs.webkit.org/show_bug.cgi?id=136701
     5
     6        Reviewed by Darin Adler.
     7
     8        After smashing NetworkResourceLoader together with the clients it can be made nicer.
     9
     10        * NetworkProcess/NetworkResourceLoadScheduler.cpp:
     11        (WebKit::NetworkResourceLoadScheduler::scheduleLoader):
     12        (WebKit::NetworkResourceLoadScheduler::removeLoader):
     13        * NetworkProcess/NetworkResourceLoader.cpp:
     14        (WebKit::NetworkResourceLoader::SynchronousLoadData::SynchronousLoadData):
     15
     16            The original request is now part of the loader.
     17
     18        (WebKit::sendReplyToSynchronousRequest):
     19        (WebKit::NetworkResourceLoader::NetworkResourceLoader):
     20
     21            Instead of copying everything out from NetworkResourceLoadParameters just include the whole thing as a const field.
     22            SanboxExtension construction moves to NetworkResourceLoadParameters::decode()
     23            Stuff that is related to starting the load moves to start().
     24
     25        (WebKit::NetworkResourceLoader::~NetworkResourceLoader):
     26        (WebKit::NetworkResourceLoader::start):
     27        (WebKit::NetworkResourceLoader::setDefersLoading):
     28
     29            Eliminate m_deferredRequest since we now always remember the original request.
     30
     31        (WebKit::NetworkResourceLoader::cleanup):
     32        (WebKit::NetworkResourceLoader::didConvertHandleToDownload):
     33        (WebKit::NetworkResourceLoader::abort):
     34        (WebKit::NetworkResourceLoader::didReceiveResponseAsync):
     35        (WebKit::NetworkResourceLoader::didFail):
     36        (WebKit::NetworkResourceLoader::willSendRequestAsync):
     37        (WebKit::NetworkResourceLoader::continueWillSendRequest):
     38
     39            Eliminate unnecessary m_suggestedRequestForWillSendRequest.
     40
     41        (WebKit::NetworkResourceLoader::wasBlocked):
     42        (WebKit::NetworkResourceLoader::cannotShowURL):
     43        (WebKit::NetworkResourceLoader::shouldUseCredentialStorage):
     44        (WebKit::NetworkResourceLoader::didReceiveAuthenticationChallenge):
     45        (WebKit::NetworkResourceLoader::receivedCancellation):
     46        (WebKit::NetworkResourceLoader::startBufferingTimerIfNeeded):
     47        (WebKit::NetworkResourceLoader::consumeSandboxExtensions):
     48        (WebKit::NetworkResourceLoader::invalidateSandboxExtensions):
     49        (WebKit::NetworkResourceLoader::sendAbortingOnFailure):
     50        * NetworkProcess/NetworkResourceLoader.h:
     51        (WebKit::NetworkResourceLoader::originalRequest):
     52        (WebKit::NetworkResourceLoader::currentRequest):
     53        (WebKit::NetworkResourceLoader::sessionID):
     54        (WebKit::NetworkResourceLoader::defersLoading):
     55        (WebKit::NetworkResourceLoader::isLoadingMainResource):
     56        (WebKit::NetworkResourceLoader::request): Deleted.
     57        (WebKit::NetworkResourceLoader::sendAbortingOnFailure): Deleted.
     58
     59            Made private and moved to cpp.
     60
     61        * NetworkProcess/mac/NetworkDiskCacheMonitor.mm:
     62        (WebKit::NetworkDiskCacheMonitor::NetworkDiskCacheMonitor):
     63
     64            Use original request instead of the current one. This might fix a bug where we didn't use file backing over redirects.
     65
     66        * Shared/Network/NetworkResourceLoadParameters.cpp:
     67        (WebKit::NetworkResourceLoadParameters::decode):
     68
     69            Decode to SanboxExtensions to the actual type rather than a handle.
     70
     71        * Shared/Network/NetworkResourceLoadParameters.h:
     72
    1732014-09-10  Michael Catanzaro  <mcatanzaro@igalia.com>
    274

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoadScheduler.cpp

    r172927 r173468  
    2525    ASSERT(RunLoop::isMain());
    2626
    27     LOG(NetworkScheduling, "(NetworkProcess) NetworkResourceLoadScheduler::scheduleLoader resource '%s'", loader->request().url().string().utf8().data());
     27    LOG(NetworkScheduling, "(NetworkProcess) NetworkResourceLoadScheduler::scheduleLoader resource '%s'", loader->originalRequest().url().string().utf8().data());
    2828
    2929    // This request might be from WebProcess we've lost our connection to.
    … …  
    4545    ASSERT(RunLoop::isMain());
    4646
    47     LOG(NetworkScheduling, "(NetworkProcess) NetworkResourceLoadScheduler::removeLoader resource '%s'", loader->request().url().string().utf8().data());
     47    LOG(NetworkScheduling, "(NetworkProcess) NetworkResourceLoadScheduler::removeLoader resource '%s'", loader->originalRequest().url().string().utf8().data());
    4848
    4949    m_activeLoaders.remove(loader);

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

    r173423 r173468  
    5858
    5959struct NetworkResourceLoader::SynchronousLoadData {
    60         SynchronousLoadData(WebCore::ResourceRequest& request, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
    61         : m_originalRequest(request)
    62         , m_delayedReply(reply)
     60    SynchronousLoadData(PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
     61        : delayedReply(reply)
    6362    {
    64         ASSERT(m_delayedReply);
    65     }
    66     WebCore::ResourceRequest m_originalRequest;
    67     WebCore::ResourceRequest m_currentRequest;
    68     RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> m_delayedReply;
    69     WebCore::ResourceResponse m_response;
    70     WebCore::ResourceError m_error;
     63        ASSERT(delayedReply);
     64    }
     65    WebCore::ResourceRequest currentRequest;
     66    RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> delayedReply;
     67    WebCore::ResourceResponse response;
     68    WebCore::ResourceError error;
    7169};
    7270
    7371static void sendReplyToSynchronousRequest(NetworkResourceLoader::SynchronousLoadData& data, WebCore::SharedBuffer* buffer)
    7472{
    75     ASSERT(data.m_delayedReply);
    76     ASSERT(!data.m_response.isNull() || !data.m_error.isNull());
     73    ASSERT(data.delayedReply);
     74    ASSERT(!data.response.isNull() || !data.error.isNull());
    7775
    7876    Vector<char> responseBuffer;
    … …  
    8078        responseBuffer.append(buffer->data(), buffer->size());
    8179
    82     data.m_delayedReply->send(data.m_error, data.m_response, responseBuffer);
    83     data.m_delayedReply = nullptr;
     80    data.delayedReply->send(data.error, data.response, responseBuffer);
     81    data.delayedReply = nullptr;
    8482}
    8583
    8684NetworkResourceLoader::NetworkResourceLoader(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> synchronousReply)
    87     : m_bytesReceived(0)
    88     , m_handleConvertedToDownload(false)
    89     , m_identifier(parameters.identifier)
    90     , m_webPageID(parameters.webPageID)
    91     , m_webFrameID(parameters.webFrameID)
    92     , m_sessionID(parameters.sessionID)
    93     , m_request(parameters.request)
    94     , m_contentSniffingPolicy(parameters.contentSniffingPolicy)
    95     , m_allowStoredCredentials(parameters.allowStoredCredentials)
    96     , m_clientCredentialPolicy(parameters.clientCredentialPolicy)
    97     , m_shouldClearReferrerOnHTTPSToHTTPRedirect(parameters.shouldClearReferrerOnHTTPSToHTTPRedirect)
    98     , m_isLoadingMainResource(parameters.isMainResource)
     85    : m_parameters(parameters)
     86    , m_connection(connection)
     87    , m_bytesReceived(0)
     88    , m_bufferedDataEncodedDataLength(0)
     89    , m_didConvertHandleToDownload(false)
     90    , m_didConsumeSandboxExtensions(false)
    9991    , m_defersLoading(parameters.defersLoading)
    100     , m_needsCertificateInfo(parameters.needsCertificateInfo)
    101     , m_maximumBufferingTime(parameters.maximumBufferingTime)
    10292    , m_bufferingTimer(this, &NetworkResourceLoader::bufferingTimerFired)
    103     , m_sandboxExtensionsAreConsumed(false)
    104     , m_connection(connection)
    105     , m_bufferedDataEncodedDataLength(0)
    106 {
    107     // Either this loader has both a webPageID and webFrameID, or it is not allowed to ask the client for authentication credentials.
     93{
     94    ASSERT(RunLoop::isMain());
    10895    // FIXME: This is necessary because of the existence of EmptyFrameLoaderClient in WebCore.
    10996    //        Once bug 116233 is resolved, this ASSERT can just be "m_webPageID && m_webFrameID"
    110     ASSERT((m_webPageID && m_webFrameID) || m_clientCredentialPolicy == DoNotAskClientForAnyCredentials);
    111 
    112     for (size_t i = 0, count = parameters.requestBodySandboxExtensions.size(); i < count; ++i) {
    113         if (RefPtr<SandboxExtension> extension = SandboxExtension::create(parameters.requestBodySandboxExtensions[i]))
    114             m_requestBodySandboxExtensions.append(extension);
    115     }
    116 
    117     if (m_request.httpBody()) {
    118         for (const FormDataElement& element : m_request.httpBody()->elements()) {
     97    ASSERT((m_parameters.webPageID && m_parameters.webFrameID) || m_parameters.clientCredentialPolicy == DoNotAskClientForAnyCredentials);
     98
     99    if (originalRequest().httpBody()) {
     100        for (const FormDataElement& element : originalRequest().httpBody()->elements()) {
    119101            if (element.m_type == FormDataElement::Type::EncodedBlob)
    120102                m_fileReferences.appendVector(NetworkBlobRegistry::shared().filesInBlob(connection, element.m_url));
    … …  
    122104    }
    123105
    124     if (m_request.url().protocolIs("blob")) {
    125         ASSERT(!SandboxExtension::create(parameters.resourceSandboxExtension));
    126         m_fileReferences.appendVector(NetworkBlobRegistry::shared().filesInBlob(connection, m_request.url()));
    127     } else
    128 
    129     if (RefPtr<SandboxExtension> resourceSandboxExtension = SandboxExtension::create(parameters.resourceSandboxExtension))
    130         m_resourceSandboxExtensions.append(resourceSandboxExtension);
    131 
    132     ASSERT(RunLoop::isMain());
    133    
    134     if (synchronousReply || m_maximumBufferingTime > 0_ms)
    135         m_bufferedData = WebCore::SharedBuffer::create();
     106    if (originalRequest().url().protocolIs("blob")) {
     107        ASSERT(!m_parameters.resourceSandboxExtension);
     108        m_fileReferences.appendVector(NetworkBlobRegistry::shared().filesInBlob(connection, originalRequest().url()));
     109    }
    136110
    137111    if (synchronousReply)
    138         m_synchronousLoadData = std::make_unique<SynchronousLoadData>(m_request, synchronousReply);
     112        m_synchronousLoadData = std::make_unique<SynchronousLoadData>(synchronousReply);
    139113}
    140114
    … …  
    143117    ASSERT(RunLoop::isMain());
    144118    ASSERT(!m_handle);
    145     ASSERT(!isSynchronous() || !m_synchronousLoadData->m_delayedReply);
     119    ASSERT(!isSynchronous() || !m_synchronousLoadData->delayedReply);
    146120}
    147121
    … …  
    155129    ASSERT(RunLoop::isMain());
    156130
    157     if (m_defersLoading) {
    158         m_deferredRequest = m_request;
    159         return;
    160     }
     131    if (m_defersLoading)
     132        return;
    161133
    162134    // Explicit ref() balanced by a deref() in NetworkResourceLoader::cleanup()
    163135    ref();
    164136
    165     // FIXME (NetworkProcess): Set platform specific settings.
    166     m_networkingContext = RemoteNetworkingContext::create(m_sessionID, m_shouldClearReferrerOnHTTPSToHTTPRedirect);
     137    m_networkingContext = RemoteNetworkingContext::create(sessionID(), m_parameters.shouldClearReferrerOnHTTPSToHTTPRedirect);
    167138
    168139    consumeSandboxExtensions();
    169140
    170     // FIXME (NetworkProcess): Pass an actual value for defersLoading
    171     m_handle = ResourceHandle::create(m_networkingContext.get(), m_request, this, false /* defersLoading */, m_contentSniffingPolicy == SniffContent);
     141    m_currentRequest = originalRequest();
     142
     143    if (isSynchronous() || m_parameters.maximumBufferingTime > 0_ms)
     144        m_bufferedData = WebCore::SharedBuffer::create();
     145
     146    bool shouldSniff = m_parameters.contentSniffingPolicy == SniffContent;
     147    m_handle = ResourceHandle::create(m_networkingContext.get(), m_currentRequest, this, false /* defersLoading */, shouldSniff);
    172148}
    173149
    174150void NetworkResourceLoader::setDefersLoading(bool defers)
    175151{
     152    if (m_defersLoading == defers)
     153        return;
    176154    m_defersLoading = defers;
    177     if (m_handle)
     155    if (m_handle) {
    178156        m_handle->setDefersLoading(defers);
    179     if (!defers && !m_deferredRequest.isNull()) {
    180         m_request = m_deferredRequest;
    181         m_deferredRequest = ResourceRequest();
     157        return;
     158    }
     159    if (!m_defersLoading)
    182160        start();
    183     }
    184161}
    185162
    … …  
    192169    invalidateSandboxExtensions();
    193170
    194     // Tell the scheduler about this finished loader soon so it can start more network requests.
    195171    NetworkProcess::shared().networkResourceLoadScheduler().removeLoader(this);
    196172
    … …  
    206182{
    207183    ASSERT(m_handle);
    208     m_handleConvertedToDownload = true;
     184    m_didConvertHandleToDownload = true;
    209185}
    210186
    … …  
    213189    ASSERT(RunLoop::isMain());
    214190
    215     if (m_handle && !m_handleConvertedToDownload)
     191    if (m_handle && !m_didConvertHandleToDownload)
    216192        m_handle->cancel();
    217193
    … …  
    223199    ASSERT_UNUSED(handle, handle == m_handle);
    224200
    225     if (m_needsCertificateInfo)
     201    if (m_parameters.needsCertificateInfo)
    226202        response.includeCertificateInfo();
    227203
    228204    if (isSynchronous())
    229         m_synchronousLoadData->m_response = response;
     205        m_synchronousLoadData->response = response;
    230206    else
    231         sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(response, isLoadingMainResource()));
     207        sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponse(response, m_parameters.isMainResource));
    232208
    233209    // m_handle will be null if the request got aborted above.
    … …  
    235211        return;
    236212
    237     if (!m_isLoadingMainResource) {
    238         // For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message.
    239         m_handle->continueDidReceiveResponse();
    240     }
     213    // For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message.
     214    if (m_parameters.isMainResource)
     215        return;
     216
     217    m_handle->continueDidReceiveResponse();
    241218}
    242219
    … …  
    285262
    286263    if (isSynchronous()) {
    287         m_synchronousLoadData->m_error = error;
     264        m_synchronousLoadData->error = error;
    288265        sendReplyToSynchronousRequest(*m_synchronousLoadData, nullptr);
    289266    } else
    … …  
    301278    ASSERT(RunLoop::isMain());
    302279
    303     m_suggestedRequestForWillSendRequest = request;
     280    m_currentRequest = request;
    304281
    305282    if (isSynchronous()) {
    306283        // FIXME: This needs to be fixed to follow the redirect correctly even for cross-domain requests.
    307284        // This includes at least updating host records, and comparing the current request instead of the original request here.
    308         if (protocolHostAndPortAreEqual(m_synchronousLoadData->m_originalRequest.url(), request.url()))
    309             m_synchronousLoadData->m_currentRequest = request;
    310         else {
    311             ASSERT(m_synchronousLoadData->m_error.isNull());
    312             m_synchronousLoadData->m_error = SynchronousLoaderClient::platformBadResponseError();
    313             m_synchronousLoadData->m_currentRequest = ResourceRequest();
     285        if (!protocolHostAndPortAreEqual(originalRequest().url(), request.url())) {
     286            ASSERT(m_synchronousLoadData->error.isNull());
     287            m_synchronousLoadData->error = SynchronousLoaderClient::platformBadResponseError();
     288            m_currentRequest = ResourceRequest();
    314289        }
    315         continueWillSendRequest(m_synchronousLoadData->m_currentRequest);
     290        continueWillSendRequest(m_currentRequest);
    316291        return;
    317292    }
    … …  
    322297{
    323298#if PLATFORM(COCOA)
    324     m_suggestedRequestForWillSendRequest.updateFromDelegatePreservingOldProperties(newRequest.nsURLRequest(DoNotUpdateHTTPBody));
     299    m_currentRequest.updateFromDelegatePreservingOldProperties(newRequest.nsURLRequest(DoNotUpdateHTTPBody));
    325300#elif USE(SOUP)
    326301    // FIXME: Implement ResourceRequest::updateFromDelegatePreservingOldProperties. See https://bugs.webkit.org/show_bug.cgi?id=126127.
    327     m_suggestedRequestForWillSendRequest.updateFromDelegatePreservingOldProperties(newRequest);
     302    m_currentRequest.updateFromDelegatePreservingOldProperties(newRequest);
    328303#endif
    329304
    330     m_request = m_suggestedRequestForWillSendRequest;
    331     m_suggestedRequestForWillSendRequest = ResourceRequest();
    332 
    333     m_handle->continueWillSendRequest(m_request);
    334 
    335     if (m_request.isNull()) {
     305    m_handle->continueWillSendRequest(m_currentRequest);
     306
     307    if (m_currentRequest.isNull()) {
    336308        m_handle->cancel();
    337         didFail(m_handle.get(), cancelledError(m_request));
     309        didFail(m_handle.get(), cancelledError(m_currentRequest));
    338310    }
    339311}
    … …  
    361333    ASSERT_UNUSED(handle, handle == m_handle);
    362334
    363     didFail(handle, WebKit::blockedError(request()));
     335    didFail(handle, WebKit::blockedError(m_currentRequest));
    364336}
    365337
    … …  
    368340    ASSERT_UNUSED(handle, handle == m_handle);
    369341
    370     didFail(handle, WebKit::cannotShowURLError(request()));
     342    didFail(handle, WebKit::cannotShowURLError(m_currentRequest));
    371343}
    372344
    … …  
    380352    // We still need this sync version, because ResourceHandle itself uses it internally, even when the delegate uses an async one.
    381353
    382     return m_allowStoredCredentials == AllowStoredCredentials;
     354    return m_parameters.allowStoredCredentials == AllowStoredCredentials;
    383355}
    384356
    … …  
    390362    // cross-origin check before asking the client for credentials.
    391363    // Therefore we are too permissive in the case where the ClientCredentialPolicy is DoNotAskClientForCrossOriginCredentials.
    392     if (m_clientCredentialPolicy == DoNotAskClientForAnyCredentials) {
     364    if (m_parameters.clientCredentialPolicy == DoNotAskClientForAnyCredentials) {
    393365        challenge.authenticationClient()->receivedRequestToContinueWithoutCredential(challenge);
    394366        return;
    395367    }
    396368
    397     NetworkProcess::shared().authenticationManager().didReceiveAuthenticationChallenge(m_webPageID, m_webFrameID, challenge);
     369    NetworkProcess::shared().authenticationManager().didReceiveAuthenticationChallenge(m_parameters.webPageID, m_parameters.webFrameID, challenge);
    398370}
    399371
    … …  
    411383
    412384    m_handle->cancel();
    413     didFail(m_handle.get(), cancelledError(m_request));
     385    didFail(m_handle.get(), cancelledError(m_currentRequest));
    414386}
    415387
    … …  
    420392    if (m_bufferingTimer.isActive())
    421393        return;
    422     m_bufferingTimer.startOneShot(m_maximumBufferingTime);
     394    m_bufferingTimer.startOneShot(m_parameters.maximumBufferingTime);
    423395}
    424396
    … …  
    462434void NetworkResourceLoader::consumeSandboxExtensions()
    463435{
    464     for (RefPtr<SandboxExtension>& extension : m_requestBodySandboxExtensions)
     436    for (auto& extension : m_parameters.requestBodySandboxExtensions)
    465437        extension->consume();
    466438
    467     for (RefPtr<SandboxExtension>& extension : m_resourceSandboxExtensions)
     439    if (auto& extension = m_parameters.resourceSandboxExtension)
    468440        extension->consume();
    469441
    470     for (RefPtr<BlobDataFileReference>& fileReference : m_fileReferences)
     442    for (auto& fileReference : m_fileReferences)
    471443        fileReference->prepareForFileAccess();
    472444
    473     m_sandboxExtensionsAreConsumed = true;
     445    m_didConsumeSandboxExtensions = true;
    474446}
    475447
    476448void NetworkResourceLoader::invalidateSandboxExtensions()
    477449{
    478     if (m_sandboxExtensionsAreConsumed) {
    479         for (RefPtr<SandboxExtension>& extension : m_requestBodySandboxExtensions)
     450    if (m_didConsumeSandboxExtensions) {
     451        for (auto& extension : m_parameters.requestBodySandboxExtensions)
    480452            extension->revoke();
    481         for (RefPtr<SandboxExtension>& extension : m_resourceSandboxExtensions)
     453        if (auto& extension = m_parameters.resourceSandboxExtension)
    482454            extension->revoke();
    483         for (RefPtr<BlobDataFileReference>& fileReference : m_fileReferences)
     455        for (auto& fileReference : m_fileReferences)
    484456            fileReference->revokeFileAccess();
    485457    }
    486458
    487     m_requestBodySandboxExtensions.clear();
    488     m_resourceSandboxExtensions.clear();
    489459    m_fileReferences.clear();
    490460
    491     m_sandboxExtensionsAreConsumed = false;
     461    m_didConsumeSandboxExtensions = false;
     462}
     463
     464template<typename T>
     465bool NetworkResourceLoader::sendAbortingOnFailure(T&& message, unsigned messageSendFlags)
     466{
     467    bool result = messageSenderConnection()->send(std::forward<T>(message), messageSenderDestinationID(), messageSendFlags);
     468    if (!result)
     469        abort();
     470    return result;
    492471}
    493472

  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h

    r173423 r173468  
    7272    ~NetworkResourceLoader();
    7373
    74     NetworkConnectionToWebProcess* connectionToWebProcess() const { return m_connection.get(); }
     74    const WebCore::ResourceRequest& originalRequest() const { return m_parameters.request; }
    7575
    76     WebCore::ResourceRequest& request() { return m_request; }
    77     WebCore::SessionID sessionID() const { return m_sessionID; }
     76    // Changes with redirects.
     77    WebCore::ResourceRequest& currentRequest() { return m_currentRequest; }
    7878
    7979    WebCore::ResourceHandle* handle() const { return m_handle.get(); }
    … …  
    8484
    8585    void setDefersLoading(bool);
    86     bool defersLoading() const { return m_defersLoading; }
    8786
    88     // ResourceHandleClient methods
     87#if PLATFORM(COCOA)
     88    static size_t fileBackedResourceMinimumSize();
     89#endif
     90    // Message handlers.
     91    void didReceiveNetworkResourceLoaderMessage(IPC::Connection*, IPC::MessageDecoder&);
     92
     93#if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
     94    static void tryGetShareableHandleFromCFURLCachedResponse(ShareableResource::Handle&, CFCachedURLResponseRef);
     95    static void tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle&, WebCore::SharedBuffer*);
     96#endif
     97
     98#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     99    void continueCanAuthenticateAgainstProtectionSpace(bool);
     100#endif
     101    void continueWillSendRequest(const WebCore::ResourceRequest& newRequest);
     102
     103    NetworkConnectionToWebProcess* connectionToWebProcess() const { return m_connection.get(); }
     104    WebCore::SessionID sessionID() const { return m_parameters.sessionID; }
     105
     106    struct SynchronousLoadData;
     107
     108private:
     109    NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
     110
     111    // IPC::MessageSender
     112    virtual IPC::Connection* messageSenderConnection() override;
     113    virtual uint64_t messageSenderDestinationID() override { return m_parameters.identifier; }
     114
     115    // ResourceHandleClient
    89116    virtual void willSendRequestAsync(WebCore::ResourceHandle*, const WebCore::ResourceRequest&, const WebCore::ResourceResponse& redirectResponse) override;
    90117    virtual void didSendData(WebCore::ResourceHandle*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
    … …  
    101128    virtual void receivedCancellation(WebCore::ResourceHandle*, const WebCore::AuthenticationChallenge&) override;
    102129    virtual bool usesAsyncCallbacks() override { return true; }
    103 
    104130#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    105131    virtual void canAuthenticateAgainstProtectionSpaceAsync(WebCore::ResourceHandle*, const WebCore::ProtectionSpace&) override;
    106132#endif
    107 
    108133#if USE(NETWORK_CFDATA_ARRAY_CALLBACK)
    109134    virtual bool supportsDataArray() override;
    110135    virtual void didReceiveDataArray(WebCore::ResourceHandle*, CFArrayRef) override;
    111136#endif
    112 
    113137#if PLATFORM(COCOA)
    114     static size_t fileBackedResourceMinimumSize();
    115 
    116138#if USE(CFNETWORK)
    117139    virtual void willCacheResponseAsync(WebCore::ResourceHandle*, CFCachedURLResponseRef) override;
    … …  
    120142#endif
    121143#endif
    122 
    123     // Message handlers.
    124     void didReceiveNetworkResourceLoaderMessage(IPC::Connection*, IPC::MessageDecoder&);
    125 
    126 #if PLATFORM(IOS) || (PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090)
    127     static void tryGetShareableHandleFromCFURLCachedResponse(ShareableResource::Handle&, CFCachedURLResponseRef);
    128     static void tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle&, WebCore::SharedBuffer*);
    129 #endif
    130 
    131     bool isSynchronous() const;
    132     bool isLoadingMainResource() const { return m_isLoadingMainResource; }
    133 
    134     template<typename T>
    135     bool sendAbortingOnFailure(T&& message, unsigned messageSendFlags = 0)
    136     {
    137         bool result = messageSenderConnection()->send(std::forward<T>(message), messageSenderDestinationID(), messageSendFlags);
    138         if (!result)
    139             abort();
    140         return result;
    141     }
    142 
    143 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    144     void continueCanAuthenticateAgainstProtectionSpace(bool);
    145 #endif
    146     void continueWillSendRequest(const WebCore::ResourceRequest& newRequest);
    147 
    148     WebCore::SharedBuffer* bufferedData() const { return m_bufferedData.get(); }
    149 
    150     struct SynchronousLoadData;
    151 
    152 private:
    153     NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
    154 
    155     // IPC::MessageSender
    156     virtual IPC::Connection* messageSenderConnection() override;
    157     virtual uint64_t messageSenderDestinationID() override { return m_identifier; }
    158144
    159145    void continueDidReceiveResponse();
    … …  
    167153    void sendBuffer(WebCore::SharedBuffer*, int encodedDataLength);
    168154
     155    bool isSynchronous() const;
     156
    169157    void consumeSandboxExtensions();
    170158    void invalidateSandboxExtensions();
     159
     160    template<typename T> bool sendAbortingOnFailure(T&& message, unsigned messageSendFlags = 0);
     161
     162    const NetworkResourceLoadParameters m_parameters;
     163
     164    RefPtr<NetworkConnectionToWebProcess> m_connection;
    171165
    172166    RefPtr<RemoteNetworkingContext> m_networkingContext;
    173167    RefPtr<WebCore::ResourceHandle> m_handle;
    174168
    175     // Keep the suggested request around while asynchronously asking to update it, because some parts of the request don't survive IPC.
    176     WebCore::ResourceRequest m_suggestedRequestForWillSendRequest;
     169    WebCore::ResourceRequest m_currentRequest;
    177170
    178     uint64_t m_bytesReceived;
    179 
    180     bool m_handleConvertedToDownload;
     171    size_t m_bytesReceived;
     172    size_t m_bufferedDataEncodedDataLength;
     173    RefPtr<WebCore::SharedBuffer> m_bufferedData;
    181174
    182175    std::unique_ptr<SynchronousLoadData> m_synchronousLoadData;
     176    Vector<RefPtr<WebCore::BlobDataFileReference>> m_fileReferences;
    183177
    184     ResourceLoadIdentifier m_identifier;
    185     uint64_t m_webPageID;
    186     uint64_t m_webFrameID;
    187     WebCore::SessionID m_sessionID;
    188     WebCore::ResourceRequest m_request;
    189     WebCore::ResourceRequest m_deferredRequest;
    190     WebCore::ContentSniffingPolicy m_contentSniffingPolicy;
    191     WebCore::StoredCredentials m_allowStoredCredentials;
    192     WebCore::ClientCredentialPolicy m_clientCredentialPolicy;
    193     bool m_shouldClearReferrerOnHTTPSToHTTPRedirect;
    194     bool m_isLoadingMainResource;
     178    bool m_didConvertHandleToDownload;
     179    bool m_didConsumeSandboxExtensions;
    195180    bool m_defersLoading;
    196     bool m_needsCertificateInfo;
    197     const std::chrono::milliseconds m_maximumBufferingTime;
    198181
    199182    WebCore::Timer<NetworkResourceLoader> m_bufferingTimer;
    200 
    201     Vector<RefPtr<SandboxExtension>> m_requestBodySandboxExtensions;
    202     Vector<RefPtr<SandboxExtension>> m_resourceSandboxExtensions;
    203     Vector<RefPtr<WebCore::BlobDataFileReference>> m_fileReferences;
    204     bool m_sandboxExtensionsAreConsumed;
    205 
    206     RefPtr<NetworkConnectionToWebProcess> m_connection;
    207    
    208     RefPtr<WebCore::SharedBuffer> m_bufferedData;
    209     size_t m_bufferedDataEncodedDataLength;
    210183};
    211184

  • trunk/Source/WebKit2/NetworkProcess/mac/NetworkDiskCacheMonitor.mm

    r172811 r173468  
    5555
    5656NetworkDiskCacheMonitor::NetworkDiskCacheMonitor(CFCachedURLResponseRef cachedResponse, NetworkResourceLoader* loader)
    57     : DiskCacheMonitor(loader->request(), loader->sessionID(), cachedResponse)
     57    : DiskCacheMonitor(loader->originalRequest(), loader->sessionID(), cachedResponse)
    5858    , m_connectionToWebProcess(loader->connectionToWebProcess())
    5959{

  • trunk/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.cpp

    r173423 r173468  
    128128        result.request.setHTTPBody(formData.release());
    129129
    130         if (!decoder.decode(result.requestBodySandboxExtensions))
     130        SandboxExtension::HandleArray requestBodySandboxExtensionHandles;
     131        if (!decoder.decode(requestBodySandboxExtensionHandles))
    131132            return false;
     133        for (size_t i = 0; i < requestBodySandboxExtensionHandles.size(); ++i) {
     134            if (RefPtr<SandboxExtension> extension = SandboxExtension::create(requestBodySandboxExtensionHandles[i]))
     135                result.requestBodySandboxExtensions.append(extension.release());
     136        }
    132137    }
    133138
    134139    if (result.request.url().isLocalFile()) {
    135         if (!decoder.decode(result.resourceSandboxExtension))
     140        SandboxExtension::Handle resourceSandboxExtensionHandle;
     141        if (!decoder.decode(resourceSandboxExtensionHandle))
    136142            return false;
     143        result.resourceSandboxExtension = SandboxExtension::create(resourceSandboxExtensionHandle);
    137144    }
    138145

  • trunk/Source/WebKit2/Shared/Network/NetworkResourceLoadParameters.h

    r173423 r173468  
    5656    WebCore::SessionID sessionID;
    5757    WebCore::ResourceRequest request;
    58     SandboxExtension::HandleArray requestBodySandboxExtensions; // Created automatically for the sender.
    59     SandboxExtension::Handle resourceSandboxExtension; // Created automatically for the sender.
     58    Vector<RefPtr<SandboxExtension>> requestBodySandboxExtensions; // Created automatically for the sender.
     59    RefPtr<SandboxExtension> resourceSandboxExtension; // Created automatically for the sender.
    6060    WebCore::ContentSniffingPolicy contentSniffingPolicy;
    6161    WebCore::StoredCredentials allowStoredCredentials;
Note: See TracChangeset for help on using the changeset viewer.