Changeset 96060 in webkit


Ignore:
Timestamp:
Sep 26, 2011 6:29:20 PM (13 years ago)
Author:
Nate Chapin
Message:

Clean up CachedResource::load(). Collapse its
logic into a single callsite, taking just a
CachedResourceLoader and a ResourceLoaderOptions.

  1. Its 'incremental' parameter is redundant.
  2. With 'incremental' removed, the SecurityCheckPolicy is the only parameter difference between the CachedResource::load() variants. Making it a part of ResourceLoaderOptions removes yet another random enum that is passed around individually.
  3. We currently have to call setResourceLoaderOptions() before load() on a new CachedResource, so we should just take the ResourceLoaderOptions in load().

​https://bugs.webkit.org/show_bug.cgi?id=67443

Reviewed by Antti Koivisto.

No new tests, refactor only.

  • loader/DocumentThreadableLoader.cpp:
  • loader/FrameLoaderTypes.h: Move SecurityCheckPolicy to ResourceLoaderOptions.h.
  • loader/MainResourceLoader.cpp:
  • loader/NetscapePlugInStreamLoader.cpp:
  • loader/ResourceLoadScheduler.cpp:
  • loader/ResourceLoadScheduler.h:
  • loader/ResourceLoader.cpp: Enforce SecurityCheckPolicy here instead of SubresourceLoader.
  • loader/ResourceLoaderOptions.h: Store SecurityCheckPolicy on ResourceLoaderOptions.
  • loader/SubresourceLoader.cpp:
  • loader/SubresourceLoader.h:
  • loader/cache/CachedFont.cpp:
  • loader/cache/CachedFont.h:
  • loader/cache/CachedImage.cpp:
  • loader/cache/CachedImage.h:
  • loader/cache/CachedResource.cpp:
  • loader/cache/CachedResource.h:
  • loader/cache/CachedResourceLoader.cpp:

(WebCore::defaultCachedResourceOptions): Define the default ResourceLoaderOptions for

CachedResource loads here instead of as a default parameter on requestResource().

  • loader/cache/CachedResourceLoader.h:
  • loader/cache/CachedResourceRequest.cpp:

(WebCore::CachedResourceRequest::didReceiveData): Remove m_incremental, since its purpose

is already enforced in the data() implementation of every CachedResource that doesn't want
incremental loads.

  • loader/cache/CachedResourceRequest.h:
Location:
trunk/Source/WebCore
Files:
22 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r96054 r96060  
     12011-09-26  Nate Chapin  <japhet@chromium.org>
     2
     3        Clean up CachedResource::load(). Collapse its
     4        logic into a single callsite, taking just a
     5        CachedResourceLoader and a ResourceLoaderOptions.
     6
     7        1. Its 'incremental' parameter is redundant.
     8        2. With 'incremental' removed, the SecurityCheckPolicy is the only
     9           parameter difference between the CachedResource::load() variants.
     10           Making it a part of ResourceLoaderOptions removes yet another random
     11           enum that is passed around individually.
     12        3. We currently have to call setResourceLoaderOptions() before load() on a
     13           new CachedResource, so we should just take the ResourceLoaderOptions in load().
     14
     15        https://bugs.webkit.org/show_bug.cgi?id=67443
     16
     17        Reviewed by Antti Koivisto.
     18
     19        No new tests, refactor only.
     20
     21        * loader/DocumentThreadableLoader.cpp:
     22        * loader/FrameLoaderTypes.h: Move SecurityCheckPolicy to ResourceLoaderOptions.h.
     23        * loader/MainResourceLoader.cpp:
     24        * loader/NetscapePlugInStreamLoader.cpp:
     25        * loader/ResourceLoadScheduler.cpp:
     26        * loader/ResourceLoadScheduler.h:
     27        * loader/ResourceLoader.cpp: Enforce SecurityCheckPolicy here instead of SubresourceLoader.
     28        * loader/ResourceLoaderOptions.h: Store SecurityCheckPolicy on ResourceLoaderOptions.
     29        * loader/SubresourceLoader.cpp:
     30        * loader/SubresourceLoader.h:
     31        * loader/cache/CachedFont.cpp:
     32        * loader/cache/CachedFont.h:
     33        * loader/cache/CachedImage.cpp:
     34        * loader/cache/CachedImage.h:
     35        * loader/cache/CachedResource.cpp:
     36        * loader/cache/CachedResource.h:
     37        * loader/cache/CachedResourceLoader.cpp:
     38        (WebCore::defaultCachedResourceOptions): Define the default ResourceLoaderOptions for
     39            CachedResource loads here instead of as a default parameter on requestResource().
     40        * loader/cache/CachedResourceLoader.h:
     41        * loader/cache/CachedResourceRequest.cpp:
     42        (WebCore::CachedResourceRequest::didReceiveData): Remove m_incremental, since its purpose
     43            is already enforced in the data() implementation of every CachedResource that doesn't want
     44            incremental loads.
     45        * loader/cache/CachedResourceRequest.h:
     46
    1472011-09-26  Joshua Bell  <jsbell@chromium.org>
    248

  • trunk/Source/WebCore/loader/DocumentThreadableLoader.cpp

    r95901 r96060  
    310310    // Any credential should have been removed from the cross-site requests.
    311311    const KURL& requestURL = request.url();
     312    m_options.securityCheck = securityCheck;
    312313    ASSERT(m_sameOriginRequest || requestURL.user().isEmpty());
    313314    ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty());
    … …  
    336337        // Clear the loader so that any callbacks from SubresourceLoader::create will not have the old loader.
    337338        m_loader = 0;
    338         m_loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_document->frame(), this, request, ResourceLoadPriorityMedium, securityCheck, options);
     339        m_loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_document->frame(), this, request, ResourceLoadPriorityMedium, options);
    339340        return;
    340341    }

  • trunk/Source/WebCore/loader/FrameLoaderTypes.h

    r85256 r96060  
    104104    };
    105105
    106     enum SecurityCheckPolicy {
    107         SkipSecurityCheck,
    108         DoSecurityCheck
    109     };
    110 
    111106    // Passed to FrameLoader::urlSelected() and ScriptController::executeIfJavaScriptURL()
    112107    // to control whether, in the case of a JavaScript URL, executeIfJavaScriptURL() should

  • trunk/Source/WebCore/loader/MainResourceLoader.cpp

    r95919 r96060  
    6161
    6262MainResourceLoader::MainResourceLoader(Frame* frame)
    63     : ResourceLoader(frame, ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials))
     63    : ResourceLoader(frame, ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, SkipSecurityCheck))
    6464    , m_dataLoadTimer(this, &MainResourceLoader::handleDataLoadNow)
    6565    , m_loadingMultipartContent(false)

  • trunk/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp

    r95768 r96060  
    3737
    3838NetscapePlugInStreamLoader::NetscapePlugInStreamLoader(Frame* frame, NetscapePlugInStreamLoaderClient* client)
    39     : ResourceLoader(frame, ResourceLoaderOptions(SendCallbacks, SniffContent, DoNotBufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials))
     39    : ResourceLoader(frame, ResourceLoaderOptions(SendCallbacks, SniffContent, DoNotBufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, SkipSecurityCheck))
    4040    , m_client(client)
    4141{

  • trunk/Source/WebCore/loader/ResourceLoadScheduler.cpp

    r95901 r96060  
    8686}
    8787
    88 PassRefPtr<SubresourceLoader> ResourceLoadScheduler::scheduleSubresourceLoad(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, ResourceLoadPriority priority, SecurityCheckPolicy securityCheck, const ResourceLoaderOptions& options)
    89 {
    90     RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, client, request, securityCheck, options);
     88PassRefPtr<SubresourceLoader> ResourceLoadScheduler::scheduleSubresourceLoad(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
     89{
     90    RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, client, request, options);
    9191    if (loader)
    9292        scheduleLoad(loader.get(), priority);

  • trunk/Source/WebCore/loader/ResourceLoadScheduler.h

    r95901 r96060  
    5252    friend ResourceLoadScheduler* resourceLoadScheduler();
    5353
    54     PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, SubresourceLoaderClient*, const ResourceRequest&, ResourceLoadPriority, SecurityCheckPolicy, const ResourceLoaderOptions&);
     54    PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, SubresourceLoaderClient*, const ResourceRequest&, ResourceLoadPriority, const ResourceLoaderOptions&);
    5555    PassRefPtr<NetscapePlugInStreamLoader> schedulePluginStreamLoad(Frame*, NetscapePlugInStreamLoaderClient*, const ResourceRequest&);
    5656    void addMainResourceLoad(ResourceLoader*);

  • trunk/Source/WebCore/loader/ResourceLoader.cpp

    r95919 r96060  
    114114    ResourceRequest clientRequest(r);
    115115   
     116    FrameLoader* frameLoader = m_frame->loader();
     117    if (m_options.securityCheck == DoSecurityCheck && (frameLoader->state() == FrameStateProvisional || !frameLoader->activeDocumentLoader() || frameLoader->activeDocumentLoader()->isStopping())) {
     118        releaseResources();
     119        return false;
     120    }
     121   
     122    if (m_options.securityCheck == DoSecurityCheck && !m_frame->document()->securityOrigin()->canDisplay(clientRequest.url())) {
     123        FrameLoader::reportLocalLoadFailed(m_frame.get(), clientRequest.url().string());
     124        releaseResources();
     125        return false;
     126    }
     127   
    116128    // https://bugs.webkit.org/show_bug.cgi?id=26391
    117129    // The various plug-in implementations call directly to ResourceLoader::load() instead of piping requests

  • trunk/Source/WebCore/loader/ResourceLoaderOptions.h

    r95901 r96060  
    5050    DoNotBufferData
    5151};
    52    
     52
    5353enum ClientCrossOriginCredentialPolicy {
    5454    AskClientForCrossOriginCredentials,
    … …  
    5656};
    5757
     58enum SecurityCheckPolicy {
     59    SkipSecurityCheck,
     60    DoSecurityCheck
     61};
     62
    5863struct ResourceLoaderOptions {
    59     ResourceLoaderOptions() : sendLoadCallbacks(DoNotSendCallbacks), sniffContent(DoNotSniffContent), shouldBufferData(BufferData), allowCredentials(DoNotAllowStoredCredentials), crossOriginCredentialPolicy(DoNotAskClientForCrossOriginCredentials) { }
    60     ResourceLoaderOptions(SendCallbackPolicy sendLoadCallbacks, ContentSniffingPolicy sniffContent, DataBufferingPolicy shouldBufferData, StoredCredentials allowCredentials, ClientCrossOriginCredentialPolicy crossOriginCredentialPolicy)
     64    ResourceLoaderOptions() : sendLoadCallbacks(DoNotSendCallbacks), sniffContent(DoNotSniffContent), shouldBufferData(BufferData), allowCredentials(DoNotAllowStoredCredentials), crossOriginCredentialPolicy(DoNotAskClientForCrossOriginCredentials), securityCheck(DoSecurityCheck) { }
     65    ResourceLoaderOptions(SendCallbackPolicy sendLoadCallbacks, ContentSniffingPolicy sniffContent, DataBufferingPolicy shouldBufferData, StoredCredentials allowCredentials, ClientCrossOriginCredentialPolicy crossOriginCredentialPolicy, SecurityCheckPolicy securityCheck)
    6166        : sendLoadCallbacks(sendLoadCallbacks)
    6267        , sniffContent(sniffContent)
    … …  
    6469        , allowCredentials(allowCredentials)
    6570        , crossOriginCredentialPolicy(crossOriginCredentialPolicy)
     71        , securityCheck(securityCheck)
    6672    {
    6773    }
    … …  
    7177    StoredCredentials allowCredentials; // Whether HTTP credentials and cookies are sent with the request.
    7278    ClientCrossOriginCredentialPolicy crossOriginCredentialPolicy; // Whether we will ask the client for credentials (if we allow credentials at all).
     79    SecurityCheckPolicy securityCheck;
    7380};
    7481

  • trunk/Source/WebCore/loader/SubresourceLoader.cpp

    r95768 r96060  
    6262}
    6363
    64 PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, SecurityCheckPolicy securityCheck, const ResourceLoaderOptions& options)
     64PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, const ResourceLoaderOptions& options)
    6565{
    6666    if (!frame)
    … …  
    6868
    6969    FrameLoader* fl = frame->loader();
    70     if (securityCheck == DoSecurityCheck && (fl->state() == FrameStateProvisional || !fl->activeDocumentLoader() || fl->activeDocumentLoader()->isStopping()))
    71         return 0;
    72 
    7370    ResourceRequest newRequest = request;
    74 
    75     if (securityCheck == DoSecurityCheck && !frame->document()->securityOrigin()->canDisplay(request.url())) {
    76         FrameLoader::reportLocalLoadFailed(frame, request.url().string());
    77         return 0;
    78     }
    7971
    8072    // Note: We skip the Content-Security-Policy check here because we check
    … …  
    10193
    10294    RefPtr<SubresourceLoader> subloader(adoptRef(new SubresourceLoader(frame, client, options)));
    103     subloader->documentLoader()->addSubresourceLoader(subloader.get());
    10495    if (!subloader->init(newRequest))
    10596        return 0;
     97    subloader->documentLoader()->addSubresourceLoader(subloader.get());
    10698
    10799    return subloader.release();

  • trunk/Source/WebCore/loader/SubresourceLoader.h

    r95768 r96060  
    4242    class SubresourceLoader : public ResourceLoader {
    4343    public:
    44         static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, const ResourceRequest&, SecurityCheckPolicy, const ResourceLoaderOptions&);
     44        static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, const ResourceRequest&, const ResourceLoaderOptions&);
    4545
    4646        void clearClient() { m_client = 0; }

  • trunk/Source/WebCore/loader/cache/CachedFont.cpp

    r95922 r96060  
    7171}
    7272
    73 void CachedFont::load(CachedResourceLoader*)
     73void CachedFont::load(CachedResourceLoader*, const ResourceLoaderOptions& options)
    7474{
    7575    // Don't load the file yet.  Wait for an access before triggering the load.
    7676    setLoading(true);
     77    m_options = options;
    7778}
    7879
    … …  
    9899    if (!m_loadInitiated) {
    99100        m_loadInitiated = true;
    100         CachedResource::load(dl);
     101        CachedResource::load(dl, m_options);
    101102    }
    102103}

  • trunk/Source/WebCore/loader/cache/CachedFont.h

    r87239 r96060  
    5050    virtual ~CachedFont();
    5151   
    52     virtual void load(CachedResourceLoader* cachedResourceLoader);
     52    virtual void load(CachedResourceLoader*, const ResourceLoaderOptions&);
    5353
    5454    virtual void didAddClient(CachedResourceClient*);

  • trunk/Source/WebCore/loader/cache/CachedImage.cpp

    r95234 r96060  
    8282}
    8383
    84 void CachedImage::load(CachedResourceLoader* cachedResourceLoader)
     84void CachedImage::load(CachedResourceLoader* cachedResourceLoader, const ResourceLoaderOptions& options)
    8585{
    8686    if (!cachedResourceLoader || cachedResourceLoader->autoLoadImages())
    87         CachedResource::load(cachedResourceLoader, true, DoSecurityCheck);
     87        CachedResource::load(cachedResourceLoader, options);
    8888    else
    8989        setLoading(false);

  • trunk/Source/WebCore/loader/cache/CachedImage.h

    r95103 r96060  
    4343    virtual ~CachedImage();
    4444   
    45     virtual void load(CachedResourceLoader* cachedResourceLoader);
     45    virtual void load(CachedResourceLoader*, const ResourceLoaderOptions&);
    4646
    4747    Image* image() const; // Returns the nullImage() if the image is not available yet.

  • trunk/Source/WebCore/loader/cache/CachedResource.cpp

    r95768 r96060  
    9797    , m_type(type)
    9898    , m_status(Pending)
    99     , m_options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials)
    10099#ifndef NDEBUG
    101100    , m_deleted(false)
    … …  
    132131}
    133132
    134 void CachedResource::load(CachedResourceLoader* cachedResourceLoader, bool incremental, SecurityCheckPolicy securityCheck)
    135 {
     133void CachedResource::load(CachedResourceLoader* cachedResourceLoader, const ResourceLoaderOptions& options)
     134{
     135    m_options = options;
    136136    m_loading = true;
    137     m_request = CachedResourceRequest::load(cachedResourceLoader, this, incremental, securityCheck, m_options);
     137    m_request = CachedResourceRequest::load(cachedResourceLoader, this, options);
    138138    if (m_request) {
    139139        m_status = Pending;

  • trunk/Source/WebCore/loader/cache/CachedResource.h

    r94003 r96060  
    8686    CachedResource(const ResourceRequest&, Type);
    8787    virtual ~CachedResource();
    88    
    89     virtual void load(CachedResourceLoader* cachedResourceLoader)  { load(cachedResourceLoader, false, DoSecurityCheck); }
    90     void load(CachedResourceLoader*, bool incremental, SecurityCheckPolicy);
     88
     89    virtual void load(CachedResourceLoader*, const ResourceLoaderOptions&);
    9190
    9291    virtual void setEncoding(const String&) { }
    … …  
    195194    bool wasCanceled() const { return m_status == Canceled; }
    196195    bool errorOccurred() const { return (m_status == LoadError || m_status == DecodeError); }
    197    
    198     void setResourceLoaderOptions(const ResourceLoaderOptions& options) { m_options = options; }
     196
    199197    bool sendResourceLoadCallbacks() const { return m_options.sendLoadCallbacks == SendCallbacks; }
    200198   
    … …  
    243241    String m_accept;
    244242    OwnPtr<CachedResourceRequest> m_request;
     243    ResourceLoaderOptions m_options;
    245244    ResourceLoadPriority m_loadPriority;
    246245
    … …  
    280279    unsigned m_status : 3; // Status
    281280
    282     ResourceLoaderOptions m_options;
    283 
    284281#ifndef NDEBUG
    285282    bool m_deleted;

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.cpp

    r95768 r96060  
    8484}
    8585
     86static const ResourceLoaderOptions& defaultCachedResourceOptions()
     87{
     88    static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck);
     89    return options;
     90}
     91
    8692CachedResourceLoader::CachedResourceLoader(Document* document)
    8793    : m_document(document)
    … …  
    134140        }
    135141    }
    136     CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String()));
     142    CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String(), defaultCachedResourceOptions()));
    137143    if (autoLoadImages() && resource && resource->stillNeedsLoad())
    138         resource->load(this);
     144        resource->load(this, defaultCachedResourceOptions());
    139145    return resource;
    140146}
    … …  
    142148CachedFont* CachedResourceLoader::requestFont(ResourceRequest& request)
    143149{
    144     return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String()));
     150    return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String(), defaultCachedResourceOptions()));
    145151}
    146152
    147153CachedCSSStyleSheet* CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority)
    148154{
    149     return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, priority));
     155    return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, defaultCachedResourceOptions(), priority));
    150156}
    151157
    … …  
    168174        userSheet->setInCache(true);
    169175
    170     userSheet->setResourceLoaderOptions(ResourceLoaderOptions(DoNotSendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials));
    171     userSheet->load(this, /*incremental*/ false, SkipSecurityCheck);
     176    userSheet->load(this, ResourceLoaderOptions(DoNotSendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, SkipSecurityCheck));
    172177
    173178    if (!inCache)
    … …  
    179184CachedScript* CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset)
    180185{
    181     return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset));
     186    return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset, defaultCachedResourceOptions()));
    182187}
    183188
    … …  
    185190CachedXSLStyleSheet* CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request)
    186191{
    187     return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String()));
     192    return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String(), defaultCachedResourceOptions()));
    188193}
    189194#endif
    … …  
    194199    ASSERT(frame());
    195200    ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkPrerender || type == CachedResource::LinkSubresource);
    196     return requestResource(type, request, String(), priority);
     201    return requestResource(type, request, String(), defaultCachedResourceOptions(), priority);
    197202}
    198203#endif
    … …  
    315320}
    316321
    317 CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, ResourceLoadPriority priority, bool forPreload, const ResourceLoaderOptions& options)
     322CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, const ResourceLoaderOptions& options, ResourceLoadPriority priority, bool forPreload)
    318323{
    319324    KURL url = request.url();
    … …  
    353358        break;
    354359    case Revalidate:
    355         resource = revalidateResource(resource, priority);
     360        resource = revalidateResource(resource, priority, options);
    356361        break;
    357362    case Use:
    … …  
    370375}
    371376   
    372 CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resource, ResourceLoadPriority priority)
     377CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resource, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
    373378{
    374379    ASSERT(resource);
    … …  
    390395   
    391396    newResource->setLoadPriority(priority);
    392     newResource->load(this);
     397    newResource->load(this, options);
    393398
    394399    if (!urlProtocolIsData)
    … …  
    413418   
    414419    resource->setLoadPriority(priority);
    415     resource->setResourceLoaderOptions(options);
    416     resource->load(this);
     420    resource->load(this, options);
    417421   
    418422    if (!inCache) {
    … …  
    552556
    553557            if (image->stillNeedsLoad())
    554                 image->load(this);
     558                image->load(this, defaultCachedResourceOptions());
    555559        }
    556560    }
    … …  
    682686        encoding = charset.isEmpty() ? m_document->charset() : charset;
    683687
    684     CachedResource* resource = requestResource(type, request, encoding, ResourceLoadPriorityUnresolved, true);
     688    CachedResource* resource = requestResource(type, request, encoding, defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, true);
    685689    if (!resource || (m_preloads && m_preloads->contains(resource)))
    686690        return;

  • trunk/Source/WebCore/loader/cache/CachedResourceLoader.h

    r95768 r96060  
    110110    // FIXME: The default value for ResourceLoaderOptions will always be used currently.
    111111    // It is plumbed for http://bugs.webkit.org/show_bug.cgi?id=61225 .
    112     CachedResource* requestResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false, const ResourceLoaderOptions& = ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials));
    113     CachedResource* revalidateResource(CachedResource*, ResourceLoadPriority);
     112    CachedResource* requestResource(CachedResource::Type, ResourceRequest&, const String& charset, const ResourceLoaderOptions&, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false);
     113    CachedResource* revalidateResource(CachedResource*, ResourceLoadPriority, const ResourceLoaderOptions&);
    114114    CachedResource* loadResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority, const ResourceLoaderOptions&);
    115115    void requestPreload(CachedResource::Type, ResourceRequest&, const String& charset);

  • trunk/Source/WebCore/loader/cache/CachedResourceRequest.cpp

    r95580 r96060  
    7575#endif
    7676
    77 CachedResourceRequest::CachedResourceRequest(CachedResourceLoader* cachedResourceLoader, CachedResource* resource, bool incremental)
     77CachedResourceRequest::CachedResourceRequest(CachedResourceLoader* cachedResourceLoader, CachedResource* resource)
    7878    : m_cachedResourceLoader(cachedResourceLoader)
    7979    , m_resource(resource)
    80     , m_incremental(incremental)
    8180    , m_multipart(false)
    8281    , m_finishing(false)
    … …  
    8887}
    8988
    90 PassOwnPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoader* cachedResourceLoader, CachedResource* resource, bool incremental, SecurityCheckPolicy securityCheck, const ResourceLoaderOptions& options)
    91 {
    92     OwnPtr<CachedResourceRequest> request = adoptPtr(new CachedResourceRequest(cachedResourceLoader, resource, incremental));
     89PassOwnPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoader* cachedResourceLoader, CachedResource* resource, const ResourceLoaderOptions& options)
     90{
     91    OwnPtr<CachedResourceRequest> request = adoptPtr(new CachedResourceRequest(cachedResourceLoader, resource));
    9392
    9493    ResourceRequest resourceRequest = resource->resourceRequest();
    … …  
    125124    resourceRequest.setPriority(priority);
    126125
    127     RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(cachedResourceLoader->document()->frame(), request.get(), resourceRequest, priority, securityCheck, options);
     126    RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(cachedResourceLoader->document()->frame(), request.get(), resourceRequest, priority, options);
    128127    if (!loader || loader->reachedTerminalState()) {
    129128        // FIXME: What if resources in other frames were waiting for this revalidation?
    … …  
    272271        RefPtr<SharedBuffer> copiedData = SharedBuffer::create(data, size);
    273272        m_resource->data(copiedData.release(), true);
    274     } else if (m_incremental)
     273    } else
    275274        m_resource->data(loader->resourceData(), false);
    276275}

  • trunk/Source/WebCore/loader/cache/CachedResourceRequest.h

    r94003 r96060  
    4444    class CachedResourceRequest : private SubresourceLoaderClient {
    4545    public:
    46         static PassOwnPtr<CachedResourceRequest> load(CachedResourceLoader*, CachedResource*, bool incremental, SecurityCheckPolicy, const ResourceLoaderOptions&);
     46        static PassOwnPtr<CachedResourceRequest> load(CachedResourceLoader*, CachedResource*, const ResourceLoaderOptions&);
    4747        ~CachedResourceRequest();
    4848
    … …  
    5050
    5151    private:
    52         CachedResourceRequest(CachedResourceLoader*, CachedResource*, bool incremental);
     52        CachedResourceRequest(CachedResourceLoader*, CachedResource*);
    5353        virtual void willSendRequest(SubresourceLoader*, ResourceRequest&, const ResourceResponse&);
    5454        virtual void didReceiveResponse(SubresourceLoader*, const ResourceResponse&);
    … …  
    6262        CachedResourceLoader* m_cachedResourceLoader;
    6363        CachedResource* m_resource;
    64         bool m_incremental;
    6564        bool m_multipart;
    6665        bool m_finishing;

  • trunk/Source/WebCore/loader/icon/IconLoader.cpp

    r95768 r96060  
    7373    resourceRequest.setPriority(ResourceLoadPriorityLow);
    7474
    75     RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_frame, this, resourceRequest, ResourceLoadPriorityLow, DoSecurityCheck, ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials));
     75    RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_frame, this, resourceRequest, ResourceLoadPriorityLow, ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck));
    7676    if (!loader)
    7777        LOG_ERROR("Failed to start load for icon at url %s", m_frame->loader()->icon()->url().string().ascii().data());
Note: See TracChangeset for help on using the changeset viewer.