Changeset 154183 in webkit


Ignore:
Timestamp:
Aug 16, 2013 8:44:06 AM (11 years ago)
Author:
beidson@apple.com
Message:

(NetworkProcess) Sync XHRs should load using async ResourceHandles, not ResourceHandle::loadResourceSynchronously
https://bugs.webkit.org/show_bug.cgi?id=119493

Reviewed by Alexey Proskuryakov.

Source/WebCore:

No new tests (Covered by plenty of existing tests).

  • WebCore.exp.in:
  • WebCore.xcodeproj/project.pbxproj:
  • platform/network/SynchronousLoaderClient.h: Make platformBadResponseError public
  • platform/network/mac/ResourceHandleMac.mm:

(WebCore::ResourceHandle::platformLoadResourceSynchronously): Add comments/FIXMEs spelling out how wrong this code is.

Source/WebKit2:

This patch does the following:

  • Consolidates SchedulableLoader and NetworkResourceLoader into one class.
  • Removes SyncNetworkResourceLoader.
  • Adds a NetworkLoaderClient interface that customizes certain behaviors of the NetworkResourceLoader.
  • Implements a SynchronousNetworkLoaderClient and AsynchronousNetworkLoaderClient for the two different types of loads.

The AsynchronousNetworkLoaderClient results in messaging back progress to the WebProcess as the load progresses.
The SynchronousNetworkLoaderClient accumulates the response, data, and error to be communicated back to the WebProcess
only when the load is complete.

Update small swaths of code to reflect that NetworkResourceLoader is the One True Loader (tm):

  • NetworkProcess/HostRecord.cpp:

(WebKit::HostRecord::scheduleResourceLoader):
(WebKit::HostRecord::addLoaderInProgress):
(WebKit::removeLoaderFromQueue):
(WebKit::HostRecord::removeLoader):
(WebKit::HostRecord::servePendingRequestsForQueue):
(WebKit::HostRecord::limitsRequests):

  • NetworkProcess/HostRecord.h:
  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::NetworkConnectionToWebProcess::didClose):
(WebKit::NetworkConnectionToWebProcess::performSynchronousLoad):
(WebKit::NetworkConnectionToWebProcess::removeLoadIdentifier):

  • NetworkProcess/NetworkConnectionToWebProcess.h:
  • NetworkProcess/NetworkProcess.cpp:
  • NetworkProcess/NetworkResourceLoadScheduler.cpp:

(WebKit::NetworkResourceLoadScheduler::scheduleLoader):
(WebKit::NetworkResourceLoadScheduler::removeLoader):
(WebKit::NetworkResourceLoadScheduler::receivedRedirect):
(WebKit::NetworkResourceLoadScheduler::removeScheduledLoaders):
(WebKit::NetworkResourceLoadScheduler::scheduleRemoveLoader):

  • NetworkProcess/NetworkResourceLoadScheduler.h:

Combine ScheduleableLoader and NetworkResourceLoader into NetworkResourceLoader:

  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::NetworkResourceLoader::NetworkResourceLoader):
(WebKit::NetworkResourceLoader::~NetworkResourceLoader):
(WebKit::NetworkResourceLoader::isSynchronous):
(WebKit::NetworkResourceLoader::start):
(WebKit::NetworkResourceLoader::didReceiveResponseAsync):
(WebKit::NetworkResourceLoader::didReceiveBuffer):
(WebKit::NetworkResourceLoader::didFinishLoading):
(WebKit::NetworkResourceLoader::didFail):
(WebKit::NetworkResourceLoader::willSendRequestAsync):
(WebKit::NetworkResourceLoader::continueWillSendRequest):
(WebKit::NetworkResourceLoader::didSendData):
(WebKit::NetworkResourceLoader::shouldUseCredentialStorage):
(WebKit::NetworkResourceLoader::didReceiveAuthenticationChallenge):
(WebKit::NetworkResourceLoader::consumeSandboxExtensions):
(WebKit::NetworkResourceLoader::invalidateSandboxExtensions):
(WebKit::NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync):

  • NetworkProcess/NetworkResourceLoader.h:

(WebKit::NetworkResourceLoader::create):
(WebKit::NetworkResourceLoader::connectionToWebProcess):
(WebKit::NetworkResourceLoader::priority):
(WebKit::NetworkResourceLoader::request):
(WebKit::NetworkResourceLoader::isLoadingMainResource):
(WebKit::NetworkResourceLoader::setHostRecord):
(WebKit::NetworkResourceLoader::hostRecord):
(WebKit::NetworkResourceLoader::sendAbortingOnFailure):

Add an abstract NetworkLoaderClient to adapt a load to be either synchronous or asynchronous:

  • NetworkProcess/NetworkLoaderClient.h:

(WebKit::NetworkLoaderClient::~NetworkLoaderClient):
(WebKit::NetworkLoaderClient::isSynchronous):
(WebKit::NetworkLoaderClient::NetworkLoaderClient):

The asynchronous loader client, primarily to message progress back to the WebProcess as it happens:

  • NetworkProcess/AsynchronousNetworkLoaderClient.cpp: Added.

(WebKit::AsynchronousNetworkLoaderClient::AsynchronousNetworkLoaderClient):
(WebKit::AsynchronousNetworkLoaderClient::willSendRequest):
(WebKit::AsynchronousNetworkLoaderClient::canAuthenticateAgainstProtectionSpace):
(WebKit::AsynchronousNetworkLoaderClient::didReceiveResponse):
(WebKit::AsynchronousNetworkLoaderClient::didReceiveBuffer):
(WebKit::AsynchronousNetworkLoaderClient::didSendData):
(WebKit::AsynchronousNetworkLoaderClient::didFinishLoading):
(WebKit::AsynchronousNetworkLoaderClient::didFail):

  • NetworkProcess/AsynchronousNetworkLoaderClient.h:

(WebKit::AsynchronousNetworkLoaderClient::create):

The synchronous loader client, primarily to accumulate results of the load to send back to the WebProcess all at once:

  • NetworkProcess/SynchronousNetworkLoaderClient.cpp: Added.

(WebKit::SynchronousNetworkLoaderClient::SynchronousNetworkLoaderClient):
(WebKit::SynchronousNetworkLoaderClient::~SynchronousNetworkLoaderClient):
(WebKit::SynchronousNetworkLoaderClient::willSendRequest):
(WebKit::SynchronousNetworkLoaderClient::canAuthenticateAgainstProtectionSpace):
(WebKit::SynchronousNetworkLoaderClient::didReceiveResponse):
(WebKit::SynchronousNetworkLoaderClient::didReceiveBuffer):
(WebKit::SynchronousNetworkLoaderClient::didFinishLoading):
(WebKit::SynchronousNetworkLoaderClient::didFail):
(WebKit::SynchronousNetworkLoaderClient::sendDelayedReply):

  • NetworkProcess/SynchronousNetworkLoaderClient.h: Added.

(WebKit::SynchronousNetworkLoaderClient::create):

  • NetworkProcess/SchedulableLoader.cpp: Removed.
  • NetworkProcess/SchedulableLoader.h: Removed.
  • NetworkProcess/SyncNetworkResourceLoader.cpp: Removed.
  • NetworkProcess/SyncNetworkResourceLoader.h: Removed.
  • WebKit2.xcodeproj/project.pbxproj:
Location:
trunk/Source
Files:
3 added
3 deleted
16 edited
1 copied
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r154182 r154183  
     12013-08-16  Brady Eidson  <beidson@apple.com>
     2
     3        (NetworkProcess)  Sync XHRs should load using async ResourceHandles, not ResourceHandle::loadResourceSynchronously
     4        https://bugs.webkit.org/show_bug.cgi?id=119493
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        No new tests (Covered by plenty of existing tests).
     9
     10        * WebCore.exp.in:
     11        * WebCore.xcodeproj/project.pbxproj:
     12
     13        * platform/network/SynchronousLoaderClient.h: Make platformBadResponseError public
     14
     15        * platform/network/mac/ResourceHandleMac.mm:
     16        (WebCore::ResourceHandle::platformLoadResourceSynchronously): Add comments/FIXMEs spelling out how wrong this code is.
     17
    1182013-08-16  peavo@outlook.com  <peavo@outlook.com>
    219
  • trunk/Source/WebCore/WebCore.exp.in

    r154160 r154183  
    339339__ZN7WebCore14ResourceBufferD1Ev
    340340__ZN7WebCore14ResourceBufferD2Ev
     341__ZN7WebCore14ResourceHandle12firstRequestEv
    341342__ZN7WebCore14ResourceHandle20forceContentSniffingEv
    342343__ZN7WebCore14ResourceHandle23continueWillSendRequestERKNS_15ResourceRequestE
     
    690691__ZN7WebCore20ResourceResponseBase6setURLERKNS_4KURLE
    691692__ZN7WebCore20ResourceResponseBaseC2Ev
     693__ZN7WebCore20ResourceResponseBaseC2ERKNS_4KURLERKN3WTF6StringExS7_S7_
    692694__ZN7WebCore20SpaceSplitStringDataD1Ev
    693695__ZN7WebCore20UserGestureIndicator7s_stateE
     
    766768__ZN7WebCore23MutableStylePropertySet25ensureCSSStyleDeclarationEv
    767769__ZN7WebCore23MutableStylePropertySetD1Ev
     770__ZN7WebCore23SynchronousLoaderClient24platformBadResponseErrorEv
    768771__ZN7WebCore23createFragmentFromNodesEPNS_8DocumentERKN3WTF6VectorIPNS_4NodeELm0ENS2_15CrashOnOverflowEEE
    769772__ZN7WebCore23dataForURLComponentTypeEP5NSURLl
     
    810813__ZN7WebCore27DeviceOrientationClientMock14setOrientationEN3WTF10PassRefPtrINS_21DeviceOrientationDataEEE
    811814__ZN7WebCore27DeviceOrientationClientMockC1Ev
     815__ZN7WebCore27protocolHostAndPortAreEqualERKNS_4KURLES2_
    812816__ZN7WebCore27startObservingCookieChangesEPFvvE
    813817__ZN7WebCore28DocumentStyleSheetCollection12addUserSheetEN3WTF10PassRefPtrINS_18StyleSheetContentsEEE
  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r154142 r154183  
    53725372                E180811216FCF42F00B80D07 /* SynchronousLoaderClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E180811016FCF42E00B80D07 /* SynchronousLoaderClient.cpp */; };
    53735373                E180811616FCF9CB00B80D07 /* SynchronousLoaderClient.mm in Sources */ = {isa = PBXBuildFile; fileRef = E180811416FCF9CB00B80D07 /* SynchronousLoaderClient.mm */; };
    5374                 E180811716FCF9CB00B80D07 /* SynchronousLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = E180811516FCF9CB00B80D07 /* SynchronousLoaderClient.h */; };
     5374                E180811716FCF9CB00B80D07 /* SynchronousLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = E180811516FCF9CB00B80D07 /* SynchronousLoaderClient.h */; settings = {ATTRIBUTES = (Private, ); }; };
    53755375                E182568F0EF2B02D00933242 /* JSWorkerGlobalScope.cpp in Sources */ = {isa = PBXBuildFile; fileRef = E182568D0EF2B02D00933242 /* JSWorkerGlobalScope.cpp */; };
    53765376                E18256900EF2B02D00933242 /* JSWorkerGlobalScope.h in Headers */ = {isa = PBXBuildFile; fileRef = E182568E0EF2B02D00933242 /* JSWorkerGlobalScope.h */; };
  • trunk/Source/WebCore/platform/network/SynchronousLoaderClient.h

    r146667 r154183  
    4848    bool isDone() { return m_isDone; }
    4949
     50    static ResourceError platformBadResponseError();
     51
    5052private:
    5153    SynchronousLoaderClient()
     
    6668#endif
    6769
    68     ResourceError platformBadResponseError();
    69 
    7070    bool m_allowStoredCredentials;
    7171    ResourceResponse m_response;
  • trunk/Source/WebCore/platform/network/mac/ResourceHandleMac.mm

    r149980 r154183  
    318318        response = client->response();
    319319    else {
     320        // FIXME: We might not ever need to manufacture a response: This might all be dead code.
     321        // When exploring removal of this code, we should substitute appropriate ASSERTs.
    320322        response = ResourceResponse(request.url(), String(), 0, String(), String());
    321323        if (error.domain() == String(NSURLErrorDomain))
    322324            switch (error.errorCode()) {
    323325            case NSURLErrorUserCancelledAuthentication:
    324                 // FIXME: we should really return the actual HTTP response, but sendSynchronousRequest doesn't provide us with one.
     326                // FIXME: We don't need to manufacture a 401 response if we say continueWithoutCredentialForAuthenticationChallenge:
     327                // in which case we'll get the real failure response. A reading of SynchronousLoaderClient.mm suggests we already do this.
    325328                response.setHTTPStatusCode(401);
    326329                break;
     
    328331                response.setHTTPStatusCode(error.errorCode());
    329332            }
    330         else
     333        else {
     334            // FIXME: This is wrong. We shouldn't need to ever make up a 404.
    331335            response.setHTTPStatusCode(404);
    332     }
     336        }
     337     }
    333338
    334339    data.swap(client->mutableData());
  • trunk/Source/WebKit2/ChangeLog

    r154167 r154183  
     12013-08-16  Brady Eidson  <beidson@apple.com>
     2
     3        (NetworkProcess)  Sync XHRs should load using async ResourceHandles, not ResourceHandle::loadResourceSynchronously
     4        https://bugs.webkit.org/show_bug.cgi?id=119493
     5
     6        Reviewed by Alexey Proskuryakov.
     7
     8        This patch does the following:
     9          - Consolidates SchedulableLoader and NetworkResourceLoader into one class.
     10          - Removes SyncNetworkResourceLoader.
     11          - Adds a NetworkLoaderClient interface that customizes certain behaviors of the NetworkResourceLoader.
     12          - Implements a SynchronousNetworkLoaderClient and AsynchronousNetworkLoaderClient for the two different types of loads.
     13
     14        The AsynchronousNetworkLoaderClient results in messaging back progress to the WebProcess as the load progresses.
     15        The SynchronousNetworkLoaderClient accumulates the response, data, and error to be communicated back to the WebProcess
     16        only when the load is complete.
     17
     18        Update small swaths of code to reflect that NetworkResourceLoader is the One True Loader (tm):
     19        * NetworkProcess/HostRecord.cpp:
     20        (WebKit::HostRecord::scheduleResourceLoader):
     21        (WebKit::HostRecord::addLoaderInProgress):
     22        (WebKit::removeLoaderFromQueue):
     23        (WebKit::HostRecord::removeLoader):
     24        (WebKit::HostRecord::servePendingRequestsForQueue):
     25        (WebKit::HostRecord::limitsRequests):
     26        * NetworkProcess/HostRecord.h:
     27
     28        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
     29        (WebKit::NetworkConnectionToWebProcess::didClose):
     30        (WebKit::NetworkConnectionToWebProcess::performSynchronousLoad):
     31        (WebKit::NetworkConnectionToWebProcess::removeLoadIdentifier):
     32        * NetworkProcess/NetworkConnectionToWebProcess.h:
     33
     34        * NetworkProcess/NetworkProcess.cpp:
     35        * NetworkProcess/NetworkResourceLoadScheduler.cpp:
     36        (WebKit::NetworkResourceLoadScheduler::scheduleLoader):
     37        (WebKit::NetworkResourceLoadScheduler::removeLoader):
     38        (WebKit::NetworkResourceLoadScheduler::receivedRedirect):
     39        (WebKit::NetworkResourceLoadScheduler::removeScheduledLoaders):
     40        (WebKit::NetworkResourceLoadScheduler::scheduleRemoveLoader):
     41        * NetworkProcess/NetworkResourceLoadScheduler.h:
     42
     43        Combine ScheduleableLoader and NetworkResourceLoader into NetworkResourceLoader:
     44        * NetworkProcess/NetworkResourceLoader.cpp:
     45        (WebKit::NetworkResourceLoader::NetworkResourceLoader):
     46        (WebKit::NetworkResourceLoader::~NetworkResourceLoader):
     47        (WebKit::NetworkResourceLoader::isSynchronous):
     48        (WebKit::NetworkResourceLoader::start):
     49        (WebKit::NetworkResourceLoader::didReceiveResponseAsync):
     50        (WebKit::NetworkResourceLoader::didReceiveBuffer):
     51        (WebKit::NetworkResourceLoader::didFinishLoading):
     52        (WebKit::NetworkResourceLoader::didFail):
     53        (WebKit::NetworkResourceLoader::willSendRequestAsync):
     54        (WebKit::NetworkResourceLoader::continueWillSendRequest):
     55        (WebKit::NetworkResourceLoader::didSendData):
     56        (WebKit::NetworkResourceLoader::shouldUseCredentialStorage):
     57        (WebKit::NetworkResourceLoader::didReceiveAuthenticationChallenge):
     58        (WebKit::NetworkResourceLoader::consumeSandboxExtensions):
     59        (WebKit::NetworkResourceLoader::invalidateSandboxExtensions):
     60        (WebKit::NetworkResourceLoader::canAuthenticateAgainstProtectionSpaceAsync):
     61        * NetworkProcess/NetworkResourceLoader.h:
     62        (WebKit::NetworkResourceLoader::create):
     63        (WebKit::NetworkResourceLoader::connectionToWebProcess):
     64        (WebKit::NetworkResourceLoader::priority):
     65        (WebKit::NetworkResourceLoader::request):
     66        (WebKit::NetworkResourceLoader::isLoadingMainResource):
     67        (WebKit::NetworkResourceLoader::setHostRecord):
     68        (WebKit::NetworkResourceLoader::hostRecord):
     69        (WebKit::NetworkResourceLoader::sendAbortingOnFailure):
     70
     71        Add an abstract NetworkLoaderClient to adapt a load to be either synchronous or asynchronous:
     72        * NetworkProcess/NetworkLoaderClient.h:
     73        (WebKit::NetworkLoaderClient::~NetworkLoaderClient):
     74        (WebKit::NetworkLoaderClient::isSynchronous):
     75        (WebKit::NetworkLoaderClient::NetworkLoaderClient):
     76
     77        The asynchronous loader client, primarily to message progress back to the WebProcess as it happens:
     78        * NetworkProcess/AsynchronousNetworkLoaderClient.cpp: Added.
     79        (WebKit::AsynchronousNetworkLoaderClient::AsynchronousNetworkLoaderClient):
     80        (WebKit::AsynchronousNetworkLoaderClient::willSendRequest):
     81        (WebKit::AsynchronousNetworkLoaderClient::canAuthenticateAgainstProtectionSpace):
     82        (WebKit::AsynchronousNetworkLoaderClient::didReceiveResponse):
     83        (WebKit::AsynchronousNetworkLoaderClient::didReceiveBuffer):
     84        (WebKit::AsynchronousNetworkLoaderClient::didSendData):
     85        (WebKit::AsynchronousNetworkLoaderClient::didFinishLoading):
     86        (WebKit::AsynchronousNetworkLoaderClient::didFail):
     87        * NetworkProcess/AsynchronousNetworkLoaderClient.h:
     88        (WebKit::AsynchronousNetworkLoaderClient::create):
     89
     90        The synchronous loader client, primarily to accumulate results of the load to send back to the WebProcess all at once:
     91        * NetworkProcess/SynchronousNetworkLoaderClient.cpp: Added.
     92        (WebKit::SynchronousNetworkLoaderClient::SynchronousNetworkLoaderClient):
     93        (WebKit::SynchronousNetworkLoaderClient::~SynchronousNetworkLoaderClient):
     94        (WebKit::SynchronousNetworkLoaderClient::willSendRequest):
     95        (WebKit::SynchronousNetworkLoaderClient::canAuthenticateAgainstProtectionSpace):
     96        (WebKit::SynchronousNetworkLoaderClient::didReceiveResponse):
     97        (WebKit::SynchronousNetworkLoaderClient::didReceiveBuffer):
     98        (WebKit::SynchronousNetworkLoaderClient::didFinishLoading):
     99        (WebKit::SynchronousNetworkLoaderClient::didFail):
     100        (WebKit::SynchronousNetworkLoaderClient::sendDelayedReply):
     101        * NetworkProcess/SynchronousNetworkLoaderClient.h: Added.
     102        (WebKit::SynchronousNetworkLoaderClient::create):
     103
     104        * NetworkProcess/SchedulableLoader.cpp: Removed.
     105        * NetworkProcess/SchedulableLoader.h: Removed.
     106        * NetworkProcess/SyncNetworkResourceLoader.cpp: Removed.
     107        * NetworkProcess/SyncNetworkResourceLoader.h: Removed.
     108
     109        * WebKit2.xcodeproj/project.pbxproj:
     110
    11112013-08-16  Gabor Rapcsanyi  <rgabor@webkit.org>
    2112
  • trunk/Source/WebKit2/NetworkProcess/AsynchronousNetworkLoaderClient.h

    r154182 r154183  
    2424 */
    2525
    26 #ifndef SyncNetworkResourceLoader_h
    27 #define SyncNetworkResourceLoader_h
     26#ifndef AsynchronousNetworkLoaderClient_h
     27#define AsynchronousNetworkLoaderClient_h
    2828
    29 #include "NetworkConnectionToWebProcessMessages.h"
    30 #include "SchedulableLoader.h"
    31 #include <wtf/RefCounted.h>
     29#include "NetworkLoaderClient.h"
     30#include "ShareableResource.h"
     31#include <wtf/PassOwnPtr.h>
    3232
    3333#if ENABLE(NETWORK_PROCESS)
     
    3535namespace WebKit {
    3636
    37 class SyncNetworkResourceLoader : public SchedulableLoader {
     37class AsynchronousNetworkLoaderClient : public NetworkLoaderClient {
    3838public:
    39     static PassRefPtr<SyncNetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
     39    static PassOwnPtr<NetworkLoaderClient> create()
    4040    {
    41         return adoptRef(new SyncNetworkResourceLoader(parameters, connection, reply));
     41        return adoptPtr(new AsynchronousNetworkLoaderClient());
    4242    }
    4343
    44     virtual void start() OVERRIDE;
    45     virtual void abort() OVERRIDE;
     44private:
     45    AsynchronousNetworkLoaderClient();
    4646
    47     virtual bool isSynchronous() OVERRIDE { return true; }
    48 
    49 private:
    50     SyncNetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
    51    
    52     void cleanup();
    53    
    54     RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> m_delayedReply;
     47    virtual void willSendRequest(NetworkResourceLoader*, WebCore::ResourceRequest& newRequest, const WebCore::ResourceResponse& redirectResponse) OVERRIDE;
     48    virtual void canAuthenticateAgainstProtectionSpace(NetworkResourceLoader*, const WebCore::ProtectionSpace&) OVERRIDE;
     49    virtual void didReceiveResponse(NetworkResourceLoader*, const WebCore::ResourceResponse&) OVERRIDE;
     50    virtual void didReceiveBuffer(NetworkResourceLoader*, WebCore::SharedBuffer*, int encodedDataLength) OVERRIDE;
     51    virtual void didSendData(NetworkResourceLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) OVERRIDE;
     52    virtual void didFinishLoading(NetworkResourceLoader*, double finishTime) OVERRIDE;
     53    virtual void didFail(NetworkResourceLoader*, const WebCore::ResourceError&) OVERRIDE;
    5554};
    5655
     
    5958#endif // ENABLE(NETWORK_PROCESS)
    6059
    61 #endif // SyncNetworkResourceLoader_h
     60#endif // AsynchronousNetworkLoaderClient_h
  • trunk/Source/WebKit2/NetworkProcess/HostRecord.cpp

    r151795 r154183  
    3333#include "NetworkResourceLoadScheduler.h"
    3434#include "NetworkResourceLoader.h"
    35 #include "SyncNetworkResourceLoader.h"
    3635#include <wtf/MainThread.h>
    3736
     
    5756}
    5857
    59 void HostRecord::scheduleResourceLoader(PassRefPtr<SchedulableLoader> loader)
     58void HostRecord::scheduleResourceLoader(PassRefPtr<NetworkResourceLoader> loader)
    6059{
    6160    ASSERT(isMainThread());
     
    6968}
    7069
    71 void HostRecord::addLoaderInProgress(SchedulableLoader* loader)
     70void HostRecord::addLoaderInProgress(NetworkResourceLoader* loader)
    7271{
    7372    ASSERT(isMainThread());
     
    7776}
    7877
    79 inline bool removeLoaderFromQueue(SchedulableLoader* loader, LoaderQueue& queue)
     78inline bool removeLoaderFromQueue(NetworkResourceLoader* loader, LoaderQueue& queue)
    8079{
    8180    LoaderQueue::iterator end = queue.end();
     
    9089}
    9190
    92 void HostRecord::removeLoader(SchedulableLoader* loader)
     91void HostRecord::removeLoader(NetworkResourceLoader* loader)
    9392{
    9493    ASSERT(isMainThread());
     
    9796    // It would be nice to know the loader has already been removed and treat it as a no-op.
    9897
    99     SchedulableLoaderSet::iterator i = m_loadersInProgress.find(loader);
     98    NetworkResourceLoaderSet::iterator i = m_loadersInProgress.find(loader);
    10099    if (i != m_loadersInProgress.end()) {
    101100        i->get()->setHostRecord(0);
     
    161160   
    162161    while (!queue.isEmpty()) {
    163         RefPtr<SchedulableLoader> loader = queue.first();
     162        RefPtr<NetworkResourceLoader> loader = queue.first();
    164163        ASSERT(loader->hostRecord() == this);
    165164
     
    194193}
    195194
    196 bool HostRecord::limitsRequests(ResourceLoadPriority priority, SchedulableLoader* loader) const
     195bool HostRecord::limitsRequests(ResourceLoadPriority priority, NetworkResourceLoader* loader) const
    197196{
    198197    ASSERT(loader);
     
    214213#ifndef NDEBUG
    215214        // If we have more loaders in progress than we should, at least one of them had better be synchronous.
    216         SchedulableLoaderSet::iterator i = m_loadersInProgress.begin();
    217         SchedulableLoaderSet::iterator end = m_loadersInProgress.end();
     215        NetworkResourceLoaderSet::iterator i = m_loadersInProgress.begin();
     216        NetworkResourceLoaderSet::iterator end = m_loadersInProgress.end();
    218217        for (; i != end; ++i) {
    219218            if (i->get()->isSynchronous())
  • trunk/Source/WebKit2/NetworkProcess/HostRecord.h

    r151795 r154183  
    3838
    3939class NetworkResourceLoader;
    40 class SchedulableLoader;
    41 class SyncNetworkResourceLoader;
    4240
    43 typedef Deque<RefPtr<SchedulableLoader>> LoaderQueue;
     41typedef Deque<RefPtr<NetworkResourceLoader>> LoaderQueue;
    4442typedef uint64_t ResourceLoadIdentifier;
    4543
     
    5553    const String& name() const { return m_name; }
    5654   
    57     void scheduleResourceLoader(PassRefPtr<SchedulableLoader>);
    58     void addLoaderInProgress(SchedulableLoader*);
    59     void removeLoader(SchedulableLoader*);
     55    void scheduleResourceLoader(PassRefPtr<NetworkResourceLoader>);
     56    void addLoaderInProgress(NetworkResourceLoader*);
     57    void removeLoader(NetworkResourceLoader*);
    6058    bool hasRequests() const;
    6159    void servePendingRequests(WebCore::ResourceLoadPriority);
     
    6866
    6967    void servePendingRequestsForQueue(LoaderQueue&, WebCore::ResourceLoadPriority);
    70     bool limitsRequests(WebCore::ResourceLoadPriority, SchedulableLoader*) const;
     68    bool limitsRequests(WebCore::ResourceLoadPriority, NetworkResourceLoader*) const;
    7169
    7270    LoaderQueue m_loadersPending[WebCore::ResourceLoadPriorityHighest + 1];
    7371    LoaderQueue m_syncLoadersPending;
    7472
    75     typedef HashSet<RefPtr<SchedulableLoader>> SchedulableLoaderSet;
    76     SchedulableLoaderSet m_loadersInProgress;
     73    typedef HashSet<RefPtr<NetworkResourceLoader>> NetworkResourceLoaderSet;
     74    NetworkResourceLoaderSet m_loadersInProgress;
    7775
    7876    const String m_name;
  • trunk/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r150609 r154183  
    3636#include "NetworkResourceLoaderMessages.h"
    3737#include "RemoteNetworkingContext.h"
    38 #include "SyncNetworkResourceLoader.h"
    3938#include <WebCore/BlobData.h>
    4039#include <WebCore/PlatformCookieJar.h>
     
    101100        i->value->abort();
    102101
    103     HashMap<ResourceLoadIdentifier, RefPtr<SyncNetworkResourceLoader>>::iterator syncEnd = m_syncNetworkResourceLoaders.end();
    104     for (HashMap<ResourceLoadIdentifier, RefPtr<SyncNetworkResourceLoader>>::iterator i = m_syncNetworkResourceLoaders.begin(); i != syncEnd; ++i)
    105         i->value->abort();
    106 
    107102    NetworkBlobRegistry::shared().connectionToWebProcessDidClose(this);
    108103
     
    125120void NetworkConnectionToWebProcess::performSynchronousLoad(const NetworkResourceLoadParameters& loadParameters, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
    126121{
    127     RefPtr<SyncNetworkResourceLoader> loader = SyncNetworkResourceLoader::create(loadParameters, this, reply);
    128     m_syncNetworkResourceLoaders.add(loadParameters.identifier, loader);
     122    RefPtr<NetworkResourceLoader> loader = NetworkResourceLoader::create(loadParameters, this, reply);
     123    m_networkResourceLoaders.add(loadParameters.identifier, loader);
    129124    NetworkProcess::shared().networkResourceLoadScheduler().scheduleLoader(loader.get());
    130125}
     
    132127void NetworkConnectionToWebProcess::removeLoadIdentifier(ResourceLoadIdentifier identifier)
    133128{
    134     RefPtr<SchedulableLoader> loader = m_networkResourceLoaders.take(identifier);
    135     if (!loader)
    136         loader = m_syncNetworkResourceLoaders.take(identifier);
     129    RefPtr<NetworkResourceLoader> loader = m_networkResourceLoaders.take(identifier);
    137130
    138131    // It's possible we have no loader for this identifier if the NetworkProcess crashed and this was a respawned NetworkProcess.
  • trunk/Source/WebKit2/NetworkProcess/NetworkConnectionToWebProcess.h

    r149848 r154183  
    9494
    9595    HashMap<ResourceLoadIdentifier, RefPtr<NetworkResourceLoader>> m_networkResourceLoaders;
    96     HashMap<ResourceLoadIdentifier, RefPtr<SyncNetworkResourceLoader>> m_syncNetworkResourceLoaders;
    9796
    9897    bool m_serialLoadingEnabled;
  • trunk/Source/WebKit2/NetworkProcess/NetworkLoaderClient.h

    r154182 r154183  
    2424 */
    2525
    26 #ifndef SyncNetworkResourceLoader_h
    27 #define SyncNetworkResourceLoader_h
     26#ifndef NetworkLoaderClient_h
     27#define NetworkLoaderClient_h
    2828
    29 #include "NetworkConnectionToWebProcessMessages.h"
    30 #include "SchedulableLoader.h"
    3129#include <wtf/RefCounted.h>
    3230
    3331#if ENABLE(NETWORK_PROCESS)
    3432
     33namespace WebCore {
     34class ProtectionSpace;
     35class ResourceError;
     36class ResourceRequest;
     37class ResourceResponse;
     38class SharedBuffer;
     39}
     40
    3541namespace WebKit {
    3642
    37 class SyncNetworkResourceLoader : public SchedulableLoader {
     43class NetworkResourceLoader;
     44
     45class NetworkLoaderClient {
    3846public:
    39     static PassRefPtr<SyncNetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
    40     {
    41         return adoptRef(new SyncNetworkResourceLoader(parameters, connection, reply));
    42     }
     47    virtual ~NetworkLoaderClient() { }
    4348
    44     virtual void start() OVERRIDE;
    45     virtual void abort() OVERRIDE;
     49    virtual void willSendRequest(NetworkResourceLoader*, WebCore::ResourceRequest& newRequest, const WebCore::ResourceResponse& redirectResponse) = 0;
     50    virtual void canAuthenticateAgainstProtectionSpace(NetworkResourceLoader*, const WebCore::ProtectionSpace&) = 0;
     51    virtual void didReceiveResponse(NetworkResourceLoader*, const WebCore::ResourceResponse&) = 0;
     52    virtual void didReceiveBuffer(NetworkResourceLoader*, WebCore::SharedBuffer*, int encodedDataLength) = 0;
     53    virtual void didSendData(NetworkResourceLoader*, unsigned long long bytesSent, unsigned long long totalBytesToBeSent) = 0;
     54    virtual void didFinishLoading(NetworkResourceLoader*, double finishTime) = 0;
     55    virtual void didFail(NetworkResourceLoader*, const WebCore::ResourceError&) = 0;
    4656
    47     virtual bool isSynchronous() OVERRIDE { return true; }
     57    virtual bool isSynchronous() { return false; }
    4858
    49 private:
    50     SyncNetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
    51    
    52     void cleanup();
    53    
    54     RefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> m_delayedReply;
     59protected:
     60    NetworkLoaderClient() { }
    5561};
    5662
     
    5965#endif // ENABLE(NETWORK_PROCESS)
    6066
    61 #endif // SyncNetworkResourceLoader_h
     67#endif // NetworkLoaderClient_h
  • trunk/Source/WebKit2/NetworkProcess/NetworkProcess.cpp

    r154144 r154183  
    3838#include "NetworkProcessPlatformStrategies.h"
    3939#include "NetworkProcessProxyMessages.h"
     40#include "NetworkResourceLoader.h"
    4041#include "RemoteNetworkingContext.h"
    41 #include "SchedulableLoader.h"
    4242#include "StatisticsData.h"
    4343#include "WebContextMessages.h"
  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoadScheduler.cpp

    r151795 r154183  
    77#include "NetworkResourceLoadParameters.h"
    88#include "NetworkResourceLoader.h"
    9 #include "SyncNetworkResourceLoader.h"
    109#include <wtf/MainThread.h>
    1110#include <wtf/text/CString.h>
     
    3837}
    3938
    40 void NetworkResourceLoadScheduler::scheduleLoader(PassRefPtr<SchedulableLoader> loader)
     39void NetworkResourceLoadScheduler::scheduleLoader(PassRefPtr<NetworkResourceLoader> loader)
    4140{
    4241    ResourceLoadPriority priority = loader->priority();
     
    7675}
    7776
    78 void NetworkResourceLoadScheduler::removeLoader(SchedulableLoader* loader)
     77void NetworkResourceLoadScheduler::removeLoader(NetworkResourceLoader* loader)
    7978{
    8079    ASSERT(isMainThread());
     
    9493}
    9594
    96 void NetworkResourceLoadScheduler::receivedRedirect(SchedulableLoader* loader, const WebCore::KURL& redirectURL)
     95void NetworkResourceLoadScheduler::receivedRedirect(NetworkResourceLoader* loader, const WebCore::KURL& redirectURL)
    9796{
    9897    ASSERT(isMainThread());
     
    149148void NetworkResourceLoadScheduler::removeScheduledLoaders()
    150149{
    151     Vector<RefPtr<SchedulableLoader>> loadersToRemove;
     150    Vector<RefPtr<NetworkResourceLoader>> loadersToRemove;
    152151    {
    153152        MutexLocker locker(m_loadersToRemoveMutex);
     
    161160}
    162161
    163 void NetworkResourceLoadScheduler::scheduleRemoveLoader(SchedulableLoader* loader)
     162void NetworkResourceLoadScheduler::scheduleRemoveLoader(NetworkResourceLoader* loader)
    164163{
    165164    MutexLocker locker(m_loadersToRemoveMutex);
  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoadScheduler.h

    r151795 r154183  
    4242
    4343class HostRecord;
    44 class SchedulableLoader;
     44class NetworkResourceLoader;
    4545
    4646class NetworkResourceLoadScheduler {
     
    5151   
    5252    // Adds the request to the queue for its host.
    53     void scheduleLoader(PassRefPtr<SchedulableLoader>);
     53    void scheduleLoader(PassRefPtr<NetworkResourceLoader>);
    5454
    5555    // Called by the WebProcess when a ResourceLoader is being cleaned up.
    56     void removeLoader(SchedulableLoader*);
     56    void removeLoader(NetworkResourceLoader*);
    5757
    5858    // Called within the NetworkProcess on a background thread when a resource load has finished.
    59     void scheduleRemoveLoader(SchedulableLoader*);
     59    void scheduleRemoveLoader(NetworkResourceLoader*);
    6060
    61     void receivedRedirect(SchedulableLoader*, const WebCore::KURL& redirectURL);
     61    void receivedRedirect(NetworkResourceLoader*, const WebCore::KURL& redirectURL);
    6262    void servePendingRequests(WebCore::ResourceLoadPriority = WebCore::ResourceLoadPriorityVeryLow);
    6363
     
    8787    HostMap m_hosts;
    8888
    89     typedef HashSet<RefPtr<SchedulableLoader>> SchedulableLoaderSet;
    90     SchedulableLoaderSet m_loaders;
     89    typedef HashSet<RefPtr<NetworkResourceLoader>> NetworkResourceLoaderSet;
     90    NetworkResourceLoaderSet m_loaders;
    9191
    9292    RefPtr<HostRecord> m_nonHTTPProtocolHost;
     
    9797   
    9898    Mutex m_loadersToRemoveMutex;
    99     Vector<RefPtr<SchedulableLoader>> m_loadersToRemove;
     99    Vector<RefPtr<NetworkResourceLoader>> m_loadersToRemove;
    100100
    101101    unsigned m_maxRequestsInFlightPerHost;
  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.cpp

    r152862 r154183  
    2929#if ENABLE(NETWORK_PROCESS)
    3030
     31#include "AsynchronousNetworkLoaderClient.h"
    3132#include "AuthenticationManager.h"
    3233#include "DataReference.h"
    3334#include "Logging.h"
     35#include "NetworkBlobRegistry.h"
    3436#include "NetworkConnectionToWebProcess.h"
    3537#include "NetworkProcess.h"
     
    4042#include "ShareableResource.h"
    4143#include "SharedMemory.h"
     44#include "SynchronousNetworkLoaderClient.h"
    4245#include "WebCoreArgumentCoders.h"
    4346#include "WebErrors.h"
     
    4649#include <WebCore/ResourceBuffer.h>
    4750#include <WebCore/ResourceHandle.h>
    48 #include <wtf/CurrentTime.h>
    4951#include <wtf/MainThread.h>
    5052
     
    5355namespace WebKit {
    5456
    55 NetworkResourceLoader::NetworkResourceLoader(const NetworkResourceLoadParameters& loadParameters, NetworkConnectionToWebProcess* connection)
    56     : SchedulableLoader(loadParameters, connection)
    57     , m_bytesReceived(0)
     57NetworkResourceLoader::NetworkResourceLoader(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
     58    : m_bytesReceived(0)
    5859    , m_handleConvertedToDownload(false)
    59 {
    60     ASSERT(isMainThread());
     60    , m_identifier(parameters.identifier)
     61    , m_webPageID(parameters.webPageID)
     62    , m_webFrameID(parameters.webFrameID)
     63    , m_request(parameters.request)
     64    , m_priority(parameters.priority)
     65    , m_contentSniffingPolicy(parameters.contentSniffingPolicy)
     66    , m_allowStoredCredentials(parameters.allowStoredCredentials)
     67    , m_clientCredentialPolicy(parameters.clientCredentialPolicy)
     68    , m_inPrivateBrowsingMode(parameters.inPrivateBrowsingMode)
     69    , m_shouldClearReferrerOnHTTPSToHTTPRedirect(parameters.shouldClearReferrerOnHTTPSToHTTPRedirect)
     70    , m_isLoadingMainResource(parameters.isMainResource)
     71    , m_sandboxExtensionsAreConsumed(false)
     72    , m_connection(connection)
     73{
     74    // Either this loader has both a webPageID and webFrameID, or it is not allowed to ask the client for authentication credentials.
     75    // FIXME: This is necessary because of the existence of EmptyFrameLoaderClient in WebCore.
     76    //        Once bug 116233 is resolved, this ASSERT can just be "m_webPageID && m_webFrameID"
     77    ASSERT((m_webPageID && m_webFrameID) || m_clientCredentialPolicy == DoNotAskClientForAnyCredentials);
     78
     79    for (size_t i = 0, count = parameters.requestBodySandboxExtensions.size(); i < count; ++i) {
     80        if (RefPtr<SandboxExtension> extension = SandboxExtension::create(parameters.requestBodySandboxExtensions[i]))
     81            m_requestBodySandboxExtensions.append(extension);
     82    }
     83
     84#if ENABLE(BLOB)
     85    if (m_request.httpBody()) {
     86        const Vector<FormDataElement>& elements = m_request.httpBody()->elements();
     87        for (size_t i = 0, count = elements.size(); i < count; ++i) {
     88            if (elements[i].m_type == FormDataElement::encodedBlob) {
     89                Vector<RefPtr<SandboxExtension>> blobElementExtensions = NetworkBlobRegistry::shared().sandboxExtensions(elements[i].m_url);
     90                m_requestBodySandboxExtensions.appendVector(blobElementExtensions);
     91            }
     92        }
     93    }
     94
     95    if (m_request.url().protocolIs("blob")) {
     96        ASSERT(!SandboxExtension::create(parameters.resourceSandboxExtension));
     97        m_resourceSandboxExtensions = NetworkBlobRegistry::shared().sandboxExtensions(m_request.url());
     98    } else
     99#endif
     100    if (RefPtr<SandboxExtension> resourceSandboxExtension = SandboxExtension::create(parameters.resourceSandboxExtension))
     101        m_resourceSandboxExtensions.append(resourceSandboxExtension);
     102
     103    ASSERT(isMainThread());
     104   
     105    if (reply)
     106        m_networkLoaderClient = SynchronousNetworkLoaderClient::create(m_request, reply);
     107    else
     108        m_networkLoaderClient = AsynchronousNetworkLoaderClient::create();
    61109}
    62110
     
    65113    ASSERT(isMainThread());
    66114    ASSERT(!m_handle);
     115    ASSERT(!m_hostRecord);
     116}
     117
     118bool NetworkResourceLoader::isSynchronous() const
     119{
     120    return m_networkLoaderClient->isSynchronous();
    67121}
    68122
     
    75129   
    76130    // FIXME (NetworkProcess): Create RemoteNetworkingContext with actual settings.
    77     m_networkingContext = RemoteNetworkingContext::create(false, false, inPrivateBrowsingMode(), shouldClearReferrerOnHTTPSToHTTPRedirect());
     131    m_networkingContext = RemoteNetworkingContext::create(false, false, m_inPrivateBrowsingMode, m_shouldClearReferrerOnHTTPSToHTTPRedirect);
    78132
    79133    consumeSandboxExtensions();
    80134
    81135    // FIXME (NetworkProcess): Pass an actual value for defersLoading
    82     m_handle = ResourceHandle::create(m_networkingContext.get(), request(), this, false /* defersLoading */, contentSniffingPolicy() == SniffContent);
     136    m_handle = ResourceHandle::create(m_networkingContext.get(), m_request, this, false /* defersLoading */, m_contentSniffingPolicy == SniffContent);
    83137}
    84138
     
    103157}
    104158
    105 template<typename U> bool NetworkResourceLoader::sendAbortingOnFailure(const U& message, unsigned messageSendFlags)
    106 {
    107     bool result = messageSenderConnection()->send(message, messageSenderDestinationID(), messageSendFlags);
    108     if (!result)
    109         abort();
    110     return result;
    111 }
    112 
    113159void NetworkResourceLoader::didConvertHandleToDownload()
    114160{
     
    135181        formData->removeGeneratedFilesIfNeeded();
    136182
    137     sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveResponseWithCertificateInfo(response, PlatformCertificateInfo(response), isLoadingMainResource()));
     183    m_networkLoaderClient->didReceiveResponse(this, response);
    138184
    139185    // m_handle will be 0 if the request got aborted above.
     
    141187        return;
    142188
    143     if (!isLoadingMainResource()) {
     189    if (!m_isLoadingMainResource) {
    144190        // For main resources, the web process is responsible for sending back a NetworkResourceLoader::ContinueDidReceiveResponse message.
    145191        m_handle->continueDidReceiveResponse();
     
    162208   
    163209    m_bytesReceived += buffer->size();
    164    
    165 #if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
    166     ShareableResource::Handle shareableResourceHandle;
    167     tryGetShareableHandleFromSharedBuffer(shareableResourceHandle, buffer.get());
    168     if (!shareableResourceHandle.isNull()) {
    169         // Since we're delivering this resource by ourselves all at once, we'll abort the resource handle since we don't need anymore callbacks from ResourceHandle.
    170         abort();
    171         send(Messages::WebResourceLoader::DidReceiveResource(shareableResourceHandle, currentTime()));
    172         return;
    173     }
    174 #endif // __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
    175 
    176     CoreIPC::DataReference dataReference(reinterpret_cast<const uint8_t*>(buffer->data()), buffer->size());
    177     sendAbortingOnFailure(Messages::WebResourceLoader::DidReceiveData(dataReference, encodedDataLength));
     210    m_networkLoaderClient->didReceiveBuffer(this, buffer.get(), encodedDataLength);
    178211}
    179212
     
    182215    ASSERT_UNUSED(handle, handle == m_handle);
    183216
    184     // FIXME (NetworkProcess): For the memory cache we'll need to update the finished status of the cached resource here.
    185     // Such bookkeeping will need to be thread safe, as this callback is happening on a background thread.
    186     send(Messages::WebResourceLoader::DidFinishResourceLoad(finishTime));
    187    
     217    m_networkLoaderClient->didFinishLoading(this, finishTime);
     218
    188219    cleanup();
    189220}
     
    193224    ASSERT_UNUSED(handle, handle == m_handle);
    194225
    195     // FIXME (NetworkProcess): For the memory cache we'll need to update the finished status of the cached resource here.
    196     // Such bookkeeping will need to be thread safe, as this callback is happening on a background thread.
    197     send(Messages::WebResourceLoader::DidFailResourceLoad(error));
     226    m_networkLoaderClient->didFail(this, error);
     227
    198228    cleanup();
    199229}
     
    207237    ASSERT(isMainThread());
    208238
     239    ResourceRequest proposedRequest = request;
    209240    m_suggestedRequestForWillSendRequest = request;
    210241
    211     // This message is DispatchMessageEvenWhenWaitingForSyncReply to avoid a situation where the NetworkProcess is deadlocked waiting for 6 connections
    212     // to complete while the WebProcess is waiting for a 7th to complete.
    213     sendAbortingOnFailure(Messages::WebResourceLoader::WillSendRequest(request, redirectResponse), CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply);
     242    m_networkLoaderClient->willSendRequest(this, proposedRequest, redirectResponse);
    214243}
    215244
     
    219248
    220249    RunLoop::main()->dispatch(bind(&NetworkResourceLoadScheduler::receivedRedirect, &NetworkProcess::shared().networkResourceLoadScheduler(), this, m_suggestedRequestForWillSendRequest.url()));
    221     m_handle->continueWillSendRequest(m_suggestedRequestForWillSendRequest);
    222 
     250
     251    m_request = m_suggestedRequestForWillSendRequest;
    223252    m_suggestedRequestForWillSendRequest = ResourceRequest();
     253
     254    m_handle->continueWillSendRequest(m_request);
     255
     256    if (m_request.isNull()) {
     257        m_handle->cancel();
     258        didFail(m_handle.get(), cancelledError(m_request));
     259    }
    224260}
    225261
     
    238274    ASSERT_UNUSED(handle, handle == m_handle);
    239275
    240     send(Messages::WebResourceLoader::DidSendData(bytesSent, totalBytesToBeSent));
     276    m_networkLoaderClient->didSendData(this, bytesSent, totalBytesToBeSent);
    241277}
    242278
     
    264300    // We still need this sync version, because ResourceHandle itself uses it internally, even when the delegate uses an async one.
    265301
    266     return allowStoredCredentials() == AllowStoredCredentials;
     302    return m_allowStoredCredentials == AllowStoredCredentials;
    267303}
    268304
     
    281317    // cross-origin check before asking the client for credentials.
    282318    // Therefore we are too permissive in the case where the ClientCredentialPolicy is DoNotAskClientForCrossOriginCredentials.
    283     if (clientCredentialPolicy() == DoNotAskClientForAnyCredentials) {
     319    if (m_clientCredentialPolicy == DoNotAskClientForAnyCredentials) {
    284320        challenge.authenticationClient()->receivedRequestToContinueWithoutCredential(challenge);
    285321        return;
    286322    }
    287323
    288     NetworkProcess::shared().authenticationManager().didReceiveAuthenticationChallenge(webPageID(), webFrameID(), challenge);
     324    NetworkProcess::shared().authenticationManager().didReceiveAuthenticationChallenge(m_webPageID, m_webFrameID, challenge);
    289325}
    290326
     
    302338}
    303339
    304 uint64_t NetworkResourceLoader::messageSenderDestinationID()
    305 {
    306     return identifier();
     340void NetworkResourceLoader::consumeSandboxExtensions()
     341{
     342    for (size_t i = 0, count = m_requestBodySandboxExtensions.size(); i < count; ++i)
     343        m_requestBodySandboxExtensions[i]->consume();
     344
     345    for (size_t i = 0, count = m_resourceSandboxExtensions.size(); i < count; ++i)
     346        m_resourceSandboxExtensions[i]->consume();
     347
     348    m_sandboxExtensionsAreConsumed = true;
     349}
     350
     351void NetworkResourceLoader::invalidateSandboxExtensions()
     352{
     353    if (m_sandboxExtensionsAreConsumed) {
     354        for (size_t i = 0, count = m_requestBodySandboxExtensions.size(); i < count; ++i)
     355            m_requestBodySandboxExtensions[i]->revoke();
     356        for (size_t i = 0, count = m_resourceSandboxExtensions.size(); i < count; ++i)
     357            m_resourceSandboxExtensions[i]->revoke();
     358    }
     359
     360    m_requestBodySandboxExtensions.clear();
     361    m_resourceSandboxExtensions.clear();
     362
     363    m_sandboxExtensionsAreConsumed = false;
    307364}
    308365
     
    313370    ASSERT_UNUSED(handle, handle == m_handle);
    314371
    315     // This message is DispatchMessageEvenWhenWaitingForSyncReply to avoid a situation where the NetworkProcess is deadlocked
    316     // waiting for 6 connections to complete while the WebProcess is waiting for a 7th to complete.
    317     sendAbortingOnFailure(Messages::WebResourceLoader::CanAuthenticateAgainstProtectionSpace(protectionSpace), CoreIPC::DispatchMessageEvenWhenWaitingForSyncReply);
     372    m_networkLoaderClient->canAuthenticateAgainstProtectionSpace(this, protectionSpace);
    318373}
    319374
  • trunk/Source/WebKit2/NetworkProcess/NetworkResourceLoader.h

    r150669 r154183  
    2929#if ENABLE(NETWORK_PROCESS)
    3030
     31#include "HostRecord.h"
    3132#include "MessageSender.h"
    32 #include "SchedulableLoader.h"
     33#include "NetworkConnectionToWebProcessMessages.h"
    3334#include "ShareableResource.h"
    3435#include <WebCore/ResourceHandleClient.h>
     36#include <WebCore/ResourceLoaderOptions.h>
     37#include <WebCore/ResourceRequest.h>
    3538#include <WebCore/RunLoop.h>
     39#include <wtf/MainThread.h>
    3640
    3741typedef const struct _CFCachedURLResponse* CFCachedURLResponseRef;
     
    4650
    4751class NetworkConnectionToWebProcess;
     52class NetworkLoaderClient;
     53class NetworkResourceLoadParameters;
    4854class RemoteNetworkingContext;
     55class SandboxExtension;
    4956
    50 class NetworkResourceLoader : public SchedulableLoader, public WebCore::ResourceHandleClient, public CoreIPC::MessageSender {
     57class NetworkResourceLoader : public RefCounted<NetworkResourceLoader>, public WebCore::ResourceHandleClient, public CoreIPC::MessageSender {
    5158public:
    5259    static RefPtr<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection)
    5360    {
    54         return adoptRef(new NetworkResourceLoader(parameters, connection));
     61        return adoptRef(new NetworkResourceLoader(parameters, connection, nullptr));
    5562    }
    5663   
     64    static RefPtr<NetworkResourceLoader> create(const NetworkResourceLoadParameters& parameters, NetworkConnectionToWebProcess* connection, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply> reply)
     65    {
     66        return adoptRef(new NetworkResourceLoader(parameters, connection, reply));
     67    }   
    5768    ~NetworkResourceLoader();
     69
     70    NetworkConnectionToWebProcess* connectionToWebProcess() const { return m_connection.get(); }
     71
     72    WebCore::ResourceLoadPriority priority() { return m_priority; }
     73    WebCore::ResourceRequest& request() { return m_request; }
    5874
    5975    WebCore::ResourceHandle* handle() const { return m_handle.get(); }
    6076    void didConvertHandleToDownload();
    6177
    62     virtual void start() OVERRIDE;
    63     virtual void abort() OVERRIDE;
     78    void start();
     79    void abort();
    6480
    6581    // ResourceHandleClient methods
     
    101117#endif
    102118
     119    bool isSynchronous() const;
     120    bool isLoadingMainResource() const { return m_isLoadingMainResource; }
     121   
     122    void setHostRecord(HostRecord* hostRecord) { ASSERT(isMainThread()); m_hostRecord = hostRecord; }
     123    HostRecord* hostRecord() const { ASSERT(isMainThread()); return m_hostRecord.get(); }
     124
     125    template<typename U> bool sendAbortingOnFailure(const U& message, unsigned messageSendFlags = 0)
     126    {
     127        bool result = messageSenderConnection()->send(message, messageSenderDestinationID(), messageSendFlags);
     128        if (!result)
     129            abort();
     130        return result;
     131    }
     132
     133
     134#if USE(PROTECTION_SPACE_AUTH_CALLBACK)
     135    void continueCanAuthenticateAgainstProtectionSpace(bool);
     136#endif
     137    void continueWillSendRequest(const WebCore::ResourceRequest& newRequest);
     138
     139#if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
     140    static void tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle&, WebCore::SharedBuffer*);
     141#endif
     142
    103143private:
    104     NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*);
     144    NetworkResourceLoader(const NetworkResourceLoadParameters&, NetworkConnectionToWebProcess*, PassRefPtr<Messages::NetworkConnectionToWebProcess::PerformSynchronousLoad::DelayedReply>);
    105145
    106146    // CoreIPC::MessageSender
    107147    virtual CoreIPC::Connection* messageSenderConnection() OVERRIDE;
    108     virtual uint64_t messageSenderDestinationID() OVERRIDE;
     148    virtual uint64_t messageSenderDestinationID() OVERRIDE { return m_identifier; }
    109149
    110     void continueWillSendRequest(const WebCore::ResourceRequest& newRequest);
    111150    void continueDidReceiveResponse();
    112 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
    113     void continueCanAuthenticateAgainstProtectionSpace(bool);
    114 #endif
    115151
    116152    void cleanup();
     
    118154    void platformDidReceiveResponse(const WebCore::ResourceResponse&);
    119155
    120     template<typename U> bool sendAbortingOnFailure(const U& message, unsigned messageSendFlags = 0);
     156    void consumeSandboxExtensions();
     157    void invalidateSandboxExtensions();
    121158
    122159    RefPtr<RemoteNetworkingContext> m_networkingContext;
     
    129166
    130167    bool m_handleConvertedToDownload;
     168    OwnPtr<NetworkLoaderClient> m_networkLoaderClient;
    131169
    132 #if __MAC_OS_X_VERSION_MIN_REQUIRED >= 1090
    133     static void tryGetShareableHandleFromSharedBuffer(ShareableResource::Handle&, WebCore::SharedBuffer*);
    134 #endif
     170    ResourceLoadIdentifier m_identifier;
     171    uint64_t m_webPageID;
     172    uint64_t m_webFrameID;
     173    WebCore::ResourceRequest m_request;
     174    WebCore::ResourceLoadPriority m_priority;
     175    WebCore::ContentSniffingPolicy m_contentSniffingPolicy;
     176    WebCore::StoredCredentials m_allowStoredCredentials;
     177    WebCore::ClientCredentialPolicy m_clientCredentialPolicy;
     178    bool m_inPrivateBrowsingMode;
     179    bool m_shouldClearReferrerOnHTTPSToHTTPRedirect;
     180    bool m_isLoadingMainResource;
     181
     182    Vector<RefPtr<SandboxExtension>> m_requestBodySandboxExtensions;
     183    Vector<RefPtr<SandboxExtension>> m_resourceSandboxExtensions;
     184    bool m_sandboxExtensionsAreConsumed;
     185
     186    RefPtr<NetworkConnectionToWebProcess> m_connection;
     187   
     188    RefPtr<HostRecord> m_hostRecord;
    135189};
    136190
  • trunk/Source/WebKit2/WebKit2.xcodeproj/project.pbxproj

    r153693 r154183  
    490490                517CF0E3163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 517CF0E1163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp */; };
    491491                517CF0E4163A486C00C2950E /* NetworkProcessConnectionMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 517CF0E2163A486C00C2950E /* NetworkProcessConnectionMessages.h */; };
    492                 51815B9F16A622210054501F /* SyncNetworkResourceLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51815B9D16A622210054501F /* SyncNetworkResourceLoader.cpp */; };
    493                 51815BA016A622210054501F /* SyncNetworkResourceLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 51815B9E16A622210054501F /* SyncNetworkResourceLoader.h */; };
    494492                51829DA51637C70C000953D6 /* NetworkResourceLoadScheduler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51829DA31637C70C000953D6 /* NetworkResourceLoadScheduler.cpp */; };
    495493                51829DA61637C70C000953D6 /* NetworkResourceLoadScheduler.h in Headers */ = {isa = PBXBuildFile; fileRef = 51829DA41637C70C000953D6 /* NetworkResourceLoadScheduler.h */; };
     
    515513                518E8F0C16B2093700E91429 /* DownloadManager.h in Headers */ = {isa = PBXBuildFile; fileRef = 518E8F0316B2093700E91429 /* DownloadManager.h */; };
    516514                518E8F0D16B2093700E91429 /* DownloadMac.mm in Sources */ = {isa = PBXBuildFile; fileRef = 518E8F0516B2093700E91429 /* DownloadMac.mm */; };
    517                 519B4FF416A9EA970066874D /* SchedulableLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 519B4FF216A9EA970066874D /* SchedulableLoader.cpp */; };
    518                 519B4FF516A9EA970066874D /* SchedulableLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 519B4FF316A9EA970066874D /* SchedulableLoader.h */; };
    519515                51A4D5A916CAC4FF000E615E /* StatisticsRequest.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51A4D5A816CAC4FF000E615E /* StatisticsRequest.cpp */; };
    520516                51A555F5128C6C47009ABCEC /* WKContextMenuItem.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51A555F3128C6C47009ABCEC /* WKContextMenuItem.cpp */; };
     
    556552                51FA2D7715212E2600C1BA0B /* WKBundleDOMWindowExtension.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51FA2D7515212E1E00C1BA0B /* WKBundleDOMWindowExtension.cpp */; };
    557553                51FB08FF1639DE1A00EC324A /* WebResourceLoadScheduler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51ABF65616392F1500132A7A /* WebResourceLoadScheduler.cpp */; };
     554                51FCB18517BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51FCB18017BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.cpp */; };
     555                51FCB18617BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 51FCB18117BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.h */; };
     556                51FCB18717BBFE0300394CD8 /* NetworkLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 51FCB18217BBFE0300394CD8 /* NetworkLoaderClient.h */; };
     557                51FCB18817BBFE0300394CD8 /* SynchronousNetworkLoaderClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51FCB18317BBFE0300394CD8 /* SynchronousNetworkLoaderClient.cpp */; };
     558                51FCB18917BBFE0300394CD8 /* SynchronousNetworkLoaderClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 51FCB18417BBFE0300394CD8 /* SynchronousNetworkLoaderClient.h */; };
    558559                51FD18B51651FBAD00DBE1CE /* NetworkResourceLoader.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 51FD18B31651FBAD00DBE1CE /* NetworkResourceLoader.cpp */; };
    559560                51FD18B61651FBAD00DBE1CE /* NetworkResourceLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = 51FD18B41651FBAD00DBE1CE /* NetworkResourceLoader.h */; };
     
    19601961                517CF0E1163A486C00C2950E /* NetworkProcessConnectionMessageReceiver.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkProcessConnectionMessageReceiver.cpp; sourceTree = "<group>"; };
    19611962                517CF0E2163A486C00C2950E /* NetworkProcessConnectionMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkProcessConnectionMessages.h; sourceTree = "<group>"; };
    1962                 51815B9D16A622210054501F /* SyncNetworkResourceLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SyncNetworkResourceLoader.cpp; path = NetworkProcess/SyncNetworkResourceLoader.cpp; sourceTree = "<group>"; };
    1963                 51815B9E16A622210054501F /* SyncNetworkResourceLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SyncNetworkResourceLoader.h; path = NetworkProcess/SyncNetworkResourceLoader.h; sourceTree = "<group>"; };
    19641963                51829DA31637C70C000953D6 /* NetworkResourceLoadScheduler.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NetworkResourceLoadScheduler.cpp; path = NetworkProcess/NetworkResourceLoadScheduler.cpp; sourceTree = "<group>"; };
    19651964                51829DA41637C70C000953D6 /* NetworkResourceLoadScheduler.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NetworkResourceLoadScheduler.h; path = NetworkProcess/NetworkResourceLoadScheduler.h; sourceTree = "<group>"; };
     
    19871986                518E8F0316B2093700E91429 /* DownloadManager.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DownloadManager.h; path = Downloads/DownloadManager.h; sourceTree = "<group>"; };
    19881987                518E8F0516B2093700E91429 /* DownloadMac.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = DownloadMac.mm; sourceTree = "<group>"; };
    1989                 519B4FF216A9EA970066874D /* SchedulableLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SchedulableLoader.cpp; path = NetworkProcess/SchedulableLoader.cpp; sourceTree = "<group>"; };
    1990                 519B4FF316A9EA970066874D /* SchedulableLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SchedulableLoader.h; path = NetworkProcess/SchedulableLoader.h; sourceTree = "<group>"; };
    19911988                51A4D5A816CAC4FF000E615E /* StatisticsRequest.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StatisticsRequest.cpp; sourceTree = "<group>"; };
    19921989                51A555F3128C6C47009ABCEC /* WKContextMenuItem.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WKContextMenuItem.cpp; sourceTree = "<group>"; };
     
    20372034                51FA2D7515212E1E00C1BA0B /* WKBundleDOMWindowExtension.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = WKBundleDOMWindowExtension.cpp; sourceTree = "<group>"; };
    20382035                51FB0902163A3B1C00EC324A /* NetworkProcessConnection.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; name = NetworkProcessConnection.messages.in; path = Network/NetworkProcessConnection.messages.in; sourceTree = "<group>"; };
     2036                51FCB18017BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AsynchronousNetworkLoaderClient.cpp; path = NetworkProcess/AsynchronousNetworkLoaderClient.cpp; sourceTree = "<group>"; };
     2037                51FCB18117BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AsynchronousNetworkLoaderClient.h; path = NetworkProcess/AsynchronousNetworkLoaderClient.h; sourceTree = "<group>"; };
     2038                51FCB18217BBFE0300394CD8 /* NetworkLoaderClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NetworkLoaderClient.h; path = NetworkProcess/NetworkLoaderClient.h; sourceTree = "<group>"; };
     2039                51FCB18317BBFE0300394CD8 /* SynchronousNetworkLoaderClient.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SynchronousNetworkLoaderClient.cpp; path = NetworkProcess/SynchronousNetworkLoaderClient.cpp; sourceTree = "<group>"; };
     2040                51FCB18417BBFE0300394CD8 /* SynchronousNetworkLoaderClient.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SynchronousNetworkLoaderClient.h; path = NetworkProcess/SynchronousNetworkLoaderClient.h; sourceTree = "<group>"; };
    20392041                51FD18B31651FBAD00DBE1CE /* NetworkResourceLoader.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = NetworkResourceLoader.cpp; path = NetworkProcess/NetworkResourceLoader.cpp; sourceTree = "<group>"; };
    20402042                51FD18B41651FBAD00DBE1CE /* NetworkResourceLoader.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = NetworkResourceLoader.h; path = NetworkProcess/NetworkResourceLoader.h; sourceTree = "<group>"; };
     
    36393641                                E1798C7616E6815500240139 /* FileAPI */,
    36403642                                510CC7DC16138E2900D03ED3 /* mac */,
     3643                                51FCB18017BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.cpp */,
     3644                                51FCB18117BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.h */,
    36413645                                512C06861638F67E00ABB911 /* HostRecord.cpp */,
    36423646                                512C06871638F67E00ABB911 /* HostRecord.h */,
     
    36443648                                513A164A1630A9BF005D7D22 /* NetworkConnectionToWebProcess.h */,
    36453649                                513A164B1630A9BF005D7D22 /* NetworkConnectionToWebProcess.messages.in */,
     3650                                51FCB18217BBFE0300394CD8 /* NetworkLoaderClient.h */,
    36463651                                510CC7DF16138E2900D03ED3 /* NetworkProcess.cpp */,
    36473652                                510CC7E016138E2900D03ED3 /* NetworkProcess.h */,
     
    36543659                                51829DA31637C70C000953D6 /* NetworkResourceLoadScheduler.cpp */,
    36553660                                51829DA41637C70C000953D6 /* NetworkResourceLoadScheduler.h */,
    3656                                 519B4FF216A9EA970066874D /* SchedulableLoader.cpp */,
    3657                                 519B4FF316A9EA970066874D /* SchedulableLoader.h */,
    3658                                 51815B9D16A622210054501F /* SyncNetworkResourceLoader.cpp */,
    3659                                 51815B9E16A622210054501F /* SyncNetworkResourceLoader.h */,
     3661                                51FCB18317BBFE0300394CD8 /* SynchronousNetworkLoaderClient.cpp */,
     3662                                51FCB18417BBFE0300394CD8 /* SynchronousNetworkLoaderClient.h */,
    36603663                        );
    36613664                        name = NetworkProcess;
     
    53995402                                1A24B5F311F531E800C38269 /* MachUtilities.h in Headers */,
    54005403                                1A232903162C867300D82F7A /* MessageDecoder.h in Headers */,
     5404                                51FCB18617BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.h in Headers */,
    54015405                                1A2328FF162C866A00D82F7A /* MessageEncoder.h in Headers */,
    54025406                                1AC4C82916B876A90069DCCD /* MessageFlags.h in Headers */,
     
    54505454                                C574A58112E66681002DFE98 /* PasteboardTypes.h in Headers */,
    54515455                                E19582D3153CBFD700B60875 /* PDFKitImports.h in Headers */,
     5456                                51FCB18917BBFE0300394CD8 /* SynchronousNetworkLoaderClient.h in Headers */,
    54525457                                BCF505E71243047B005955AE /* PlatformCertificateInfo.h in Headers */,
    54535458                                BCC43ABB127B95DC00317F16 /* PlatformPopupMenuData.h in Headers */,
     
    54945499                                1AAB4A8D1296F0A20023952F /* SandboxExtension.h in Headers */,
    54955500                                E1E552C516AE065F004ED653 /* SandboxInitializationParameters.h in Headers */,
    5496                                 519B4FF516A9EA970066874D /* SchedulableLoader.h in Headers */,
    54975501                                51D130541382EAC000351EDD /* SecItemRequestData.h in Headers */,
    54985502                                51D130561382EAC000351EDD /* SecItemResponseData.h in Headers */,
     
    55215525                                1A13BEB41635A9C800F19C03 /* StringReference.h in Headers */,
    55225526                                296BD85D15019BC30071F424 /* StringUtilities.h in Headers */,
    5523                                 51815BA016A622210054501F /* SyncNetworkResourceLoader.h in Headers */,
    55245527                                1AA417CB12C00CCA002BE67B /* TextChecker.h in Headers */,
    55255528                                1QQ417CB12C00CCA002BE67B /* TextCheckerCompletion.h in Headers */,
     
    57965799                                BCE17B7E1381F1170012A641 /* WKPagePrivateMac.h in Headers */,
    57975800                                A5EFD38C16B0E88C00B2F0E8 /* WKPageVisibilityTypes.h in Headers */,
     5801                                51FCB18717BBFE0300394CD8 /* NetworkLoaderClient.h in Headers */,
    57985802                                7C135AA9173B0BCA00586AE2 /* WKPluginInformation.h in Headers */,
    57995803                                1AC86FF4130B46D3002C1257 /* WKPluginSiteDataManager.h in Headers */,
     
    67626766                                1AAB4AAA1296F1540023952F /* SandboxExtensionMac.mm in Sources */,
    67636767                                E1E552C416AE065F004ED653 /* SandboxInitialiationParametersMac.mm in Sources */,
    6764                                 519B4FF416A9EA970066874D /* SchedulableLoader.cpp in Sources */,
    67656768                                51D130531382EAC000351EDD /* SecItemRequestData.cpp in Sources */,
    67666769                                51D130551382EAC000351EDD /* SecItemResponseData.cpp in Sources */,
     
    67956798                                1A13BEB31635A9C800F19C03 /* StringReference.cpp in Sources */,
    67966799                                296BD85E15019BC30071F424 /* StringUtilities.mm in Sources */,
    6797                                 51815B9F16A622210054501F /* SyncNetworkResourceLoader.cpp in Sources */,
    67986800                                1ZZ417EF12C00D87002BE67B /* TextCheckerCompletion.cpp in Sources */,
    67996801                                1AA417EF12C00D87002BE67B /* TextCheckerMac.mm in Sources */,
     
    69816983                                BC90A1D7122DD66A00CC8C50 /* WebURLResponseMac.mm in Sources */,
    69826984                                C0337DD1127A2980008FF4F4 /* WebWheelEvent.cpp in Sources */,
     6985                                51FCB18517BBFE0300394CD8 /* AsynchronousNetworkLoaderClient.cpp in Sources */,
    69836986                                29CD55AB128E294F00133C85 /* WKAccessibilityWebPageObject.mm in Sources */,
    69846987                                512E34E4130B4D0500ABD19A /* WKApplicationCacheManager.cpp in Sources */,
     
    70597062                                BC85806312B8505700EDEB2E /* WKOpenPanelParameters.cpp in Sources */,
    70607063                                BC85806212B8505700EDEB2E /* WKOpenPanelResultListener.cpp in Sources */,
     7064                                51FCB18817BBFE0300394CD8 /* SynchronousNetworkLoaderClient.cpp in Sources */,
    70617065                                BCD597D6112B56DC00EC8C23 /* WKPage.cpp in Sources */,
    70627066                                BC7B633812A45ABA00D174A4 /* WKPageGroup.cpp in Sources */,
Note: See TracChangeset for help on using the changeset viewer.