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:

git-svn-id: http://svn.webkit.org/repository/webkit/trunk@96060 268f45cc-cd09-0410-ab3c-d52691b4dbfc

diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
index 6dda54d..eabd6e0 100644 (file)
--- a/Source/WebCore/ChangeLog
+++ b/Source/WebCore/ChangeLog
@@ -1,3 +1,49 @@
+2011-09-26  Nate Chapin  <japhet@chromium.org>
+
+        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:
+
 2011-09-26  Joshua Bell  <jsbell@chromium.org>
 
         IndexedDB: Second half of IDBFactory.getDatabaseNames implementation

diff --git a/Source/WebCore/loader/DocumentThreadableLoader.cpp b/Source/WebCore/loader/DocumentThreadableLoader.cpp
index 0c5afa9..80e0ff2 100644 (file)
--- a/Source/WebCore/loader/DocumentThreadableLoader.cpp
+++ b/Source/WebCore/loader/DocumentThreadableLoader.cpp
@@ -309,6 +309,7 @@ void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, Secur
 {
     // Any credential should have been removed from the cross-site requests.
     const KURL& requestURL = request.url();
+    m_options.securityCheck = securityCheck;
     ASSERT(m_sameOriginRequest || requestURL.user().isEmpty());
     ASSERT(m_sameOriginRequest || requestURL.pass().isEmpty());
 
@@ -335,7 +336,7 @@ void DocumentThreadableLoader::loadRequest(const ResourceRequest& request, Secur
 
         // Clear the loader so that any callbacks from SubresourceLoader::create will not have the old loader.
         m_loader = 0;
-        m_loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_document->frame(), this, request, ResourceLoadPriorityMedium, securityCheck, options);
+        m_loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_document->frame(), this, request, ResourceLoadPriorityMedium, options);
         return;
     }
     

diff --git a/Source/WebCore/loader/FrameLoaderTypes.h b/Source/WebCore/loader/FrameLoaderTypes.h
index b86cf5e..88df126 100644 (file)
--- a/Source/WebCore/loader/FrameLoaderTypes.h
+++ b/Source/WebCore/loader/FrameLoaderTypes.h
@@ -103,11 +103,6 @@ namespace WebCore {
         SandboxAll = -1 // Mask with all bits set to 1.
     };
 
-    enum SecurityCheckPolicy {
-        SkipSecurityCheck,
-        DoSecurityCheck
-    };
-
     // Passed to FrameLoader::urlSelected() and ScriptController::executeIfJavaScriptURL()
     // to control whether, in the case of a JavaScript URL, executeIfJavaScriptURL() should
     // replace the document.  It is a FIXME to eliminate this extra parameter from

diff --git a/Source/WebCore/loader/MainResourceLoader.cpp b/Source/WebCore/loader/MainResourceLoader.cpp
index 832fae3..5810c55 100644 (file)
--- a/Source/WebCore/loader/MainResourceLoader.cpp
+++ b/Source/WebCore/loader/MainResourceLoader.cpp
@@ -60,7 +60,7 @@
 namespace WebCore {
 
 MainResourceLoader::MainResourceLoader(Frame* frame)
-    : ResourceLoader(frame, ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials))
+    : ResourceLoader(frame, ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, SkipSecurityCheck))
     , m_dataLoadTimer(this, &MainResourceLoader::handleDataLoadNow)
     , m_loadingMultipartContent(false)
     , m_waitingForContentPolicy(false)

diff --git a/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp b/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp
index 77f855f..a884ba8 100644 (file)
--- a/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp
+++ b/Source/WebCore/loader/NetscapePlugInStreamLoader.cpp
@@ -36,7 +36,7 @@
 namespace WebCore {
 
 NetscapePlugInStreamLoader::NetscapePlugInStreamLoader(Frame* frame, NetscapePlugInStreamLoaderClient* client)
-    : ResourceLoader(frame, ResourceLoaderOptions(SendCallbacks, SniffContent, DoNotBufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials))
+    : ResourceLoader(frame, ResourceLoaderOptions(SendCallbacks, SniffContent, DoNotBufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, SkipSecurityCheck))
     , m_client(client)
 {
 }

diff --git a/Source/WebCore/loader/ResourceLoadScheduler.cpp b/Source/WebCore/loader/ResourceLoadScheduler.cpp
index bea4b32..a1640fe 100644 (file)
--- a/Source/WebCore/loader/ResourceLoadScheduler.cpp
+++ b/Source/WebCore/loader/ResourceLoadScheduler.cpp
@@ -85,9 +85,9 @@ ResourceLoadScheduler::ResourceLoadScheduler()
 #endif
 }
 
-PassRefPtr<SubresourceLoader> ResourceLoadScheduler::scheduleSubresourceLoad(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, ResourceLoadPriority priority, SecurityCheckPolicy securityCheck, const ResourceLoaderOptions& options)
+PassRefPtr<SubresourceLoader> ResourceLoadScheduler::scheduleSubresourceLoad(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
 {
-    RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, client, request, securityCheck, options);
+    RefPtr<SubresourceLoader> loader = SubresourceLoader::create(frame, client, request, options);
     if (loader)
         scheduleLoad(loader.get(), priority);
     return loader.release();

diff --git a/Source/WebCore/loader/ResourceLoadScheduler.h b/Source/WebCore/loader/ResourceLoadScheduler.h
index ddeaffd..91df64d 100644 (file)
--- a/Source/WebCore/loader/ResourceLoadScheduler.h
+++ b/Source/WebCore/loader/ResourceLoadScheduler.h
@@ -51,7 +51,7 @@ class ResourceLoadScheduler {
 public:
     friend ResourceLoadScheduler* resourceLoadScheduler();
 
-    PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, SubresourceLoaderClient*, const ResourceRequest&, ResourceLoadPriority, SecurityCheckPolicy, const ResourceLoaderOptions&);
+    PassRefPtr<SubresourceLoader> scheduleSubresourceLoad(Frame*, SubresourceLoaderClient*, const ResourceRequest&, ResourceLoadPriority, const ResourceLoaderOptions&);
     PassRefPtr<NetscapePlugInStreamLoader> schedulePluginStreamLoad(Frame*, NetscapePlugInStreamLoaderClient*, const ResourceRequest&);
     void addMainResourceLoad(ResourceLoader*);
     void remove(ResourceLoader*);

diff --git a/Source/WebCore/loader/ResourceLoader.cpp b/Source/WebCore/loader/ResourceLoader.cpp
index f95aaa3..5e715f4 100644 (file)
--- a/Source/WebCore/loader/ResourceLoader.cpp
+++ b/Source/WebCore/loader/ResourceLoader.cpp
@@ -113,6 +113,18 @@ bool ResourceLoader::init(const ResourceRequest& r)
     
     ResourceRequest clientRequest(r);
     
+    FrameLoader* frameLoader = m_frame->loader();
+    if (m_options.securityCheck == DoSecurityCheck && (frameLoader->state() == FrameStateProvisional || !frameLoader->activeDocumentLoader() || frameLoader->activeDocumentLoader()->isStopping())) {
+        releaseResources();
+        return false;
+    }
+    
+    if (m_options.securityCheck == DoSecurityCheck && !m_frame->document()->securityOrigin()->canDisplay(clientRequest.url())) {
+        FrameLoader::reportLocalLoadFailed(m_frame.get(), clientRequest.url().string());
+        releaseResources();
+        return false;
+    }
+    
     // https://bugs.webkit.org/show_bug.cgi?id=26391
     // The various plug-in implementations call directly to ResourceLoader::load() instead of piping requests
     // through FrameLoader. As a result, they miss the FrameLoader::addExtraFieldsToRequest() step which sets

diff --git a/Source/WebCore/loader/ResourceLoaderOptions.h b/Source/WebCore/loader/ResourceLoaderOptions.h
index c28abe7..a290ad7 100644 (file)
--- a/Source/WebCore/loader/ResourceLoaderOptions.h
+++ b/Source/WebCore/loader/ResourceLoaderOptions.h
@@ -49,20 +49,26 @@ enum DataBufferingPolicy {
     BufferData,
     DoNotBufferData
 };
-    
+
 enum ClientCrossOriginCredentialPolicy {
     AskClientForCrossOriginCredentials,
     DoNotAskClientForCrossOriginCredentials
 };
 
+enum SecurityCheckPolicy {
+    SkipSecurityCheck,
+    DoSecurityCheck
+};
+
 struct ResourceLoaderOptions {
-    ResourceLoaderOptions() : sendLoadCallbacks(DoNotSendCallbacks), sniffContent(DoNotSniffContent), shouldBufferData(BufferData), allowCredentials(DoNotAllowStoredCredentials), crossOriginCredentialPolicy(DoNotAskClientForCrossOriginCredentials) { }
-    ResourceLoaderOptions(SendCallbackPolicy sendLoadCallbacks, ContentSniffingPolicy sniffContent, DataBufferingPolicy shouldBufferData, StoredCredentials allowCredentials, ClientCrossOriginCredentialPolicy crossOriginCredentialPolicy)
+    ResourceLoaderOptions() : sendLoadCallbacks(DoNotSendCallbacks), sniffContent(DoNotSniffContent), shouldBufferData(BufferData), allowCredentials(DoNotAllowStoredCredentials), crossOriginCredentialPolicy(DoNotAskClientForCrossOriginCredentials), securityCheck(DoSecurityCheck) { }
+    ResourceLoaderOptions(SendCallbackPolicy sendLoadCallbacks, ContentSniffingPolicy sniffContent, DataBufferingPolicy shouldBufferData, StoredCredentials allowCredentials, ClientCrossOriginCredentialPolicy crossOriginCredentialPolicy, SecurityCheckPolicy securityCheck)
         : sendLoadCallbacks(sendLoadCallbacks)
         , sniffContent(sniffContent)
         , shouldBufferData(shouldBufferData)
         , allowCredentials(allowCredentials)
         , crossOriginCredentialPolicy(crossOriginCredentialPolicy)
+        , securityCheck(securityCheck)
     {
     }
     SendCallbackPolicy sendLoadCallbacks;
@@ -70,6 +76,7 @@ struct ResourceLoaderOptions {
     DataBufferingPolicy shouldBufferData;
     StoredCredentials allowCredentials; // Whether HTTP credentials and cookies are sent with the request.
     ClientCrossOriginCredentialPolicy crossOriginCredentialPolicy; // Whether we will ask the client for credentials (if we allow credentials at all).
+    SecurityCheckPolicy securityCheck;
 };
 
 } // namespace WebCore    

diff --git a/Source/WebCore/loader/SubresourceLoader.cpp b/Source/WebCore/loader/SubresourceLoader.cpp
index a74f256..89ccb42 100644 (file)
--- a/Source/WebCore/loader/SubresourceLoader.cpp
+++ b/Source/WebCore/loader/SubresourceLoader.cpp
@@ -61,22 +61,14 @@ SubresourceLoader::~SubresourceLoader()
 #endif
 }
 
-PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, SecurityCheckPolicy securityCheck, const ResourceLoaderOptions& options)
+PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, SubresourceLoaderClient* client, const ResourceRequest& request, const ResourceLoaderOptions& options)
 {
     if (!frame)
         return 0;
 
     FrameLoader* fl = frame->loader();
-    if (securityCheck == DoSecurityCheck && (fl->state() == FrameStateProvisional || !fl->activeDocumentLoader() || fl->activeDocumentLoader()->isStopping()))
-        return 0;
-
     ResourceRequest newRequest = request;
 
-    if (securityCheck == DoSecurityCheck && !frame->document()->securityOrigin()->canDisplay(request.url())) {
-        FrameLoader::reportLocalLoadFailed(frame, request.url().string());
-        return 0;
-    }
-
     // Note: We skip the Content-Security-Policy check here because we check
     // the Content-Security-Policy at the CachedResourceLoader layer so we can
     // handle different resource types differently.
@@ -100,9 +92,9 @@ PassRefPtr<SubresourceLoader> SubresourceLoader::create(Frame* frame, Subresourc
     fl->addExtraFieldsToSubresourceRequest(newRequest);
 
     RefPtr<SubresourceLoader> subloader(adoptRef(new SubresourceLoader(frame, client, options)));
-    subloader->documentLoader()->addSubresourceLoader(subloader.get());
     if (!subloader->init(newRequest))
         return 0;
+    subloader->documentLoader()->addSubresourceLoader(subloader.get());
 
     return subloader.release();
 }

diff --git a/Source/WebCore/loader/SubresourceLoader.h b/Source/WebCore/loader/SubresourceLoader.h
index d9ca5e2..0e6f47f 100644 (file)
--- a/Source/WebCore/loader/SubresourceLoader.h
+++ b/Source/WebCore/loader/SubresourceLoader.h
@@ -41,7 +41,7 @@ namespace WebCore {
     
     class SubresourceLoader : public ResourceLoader {
     public:
-        static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, const ResourceRequest&, SecurityCheckPolicy, const ResourceLoaderOptions&);
+        static PassRefPtr<SubresourceLoader> create(Frame*, SubresourceLoaderClient*, const ResourceRequest&, const ResourceLoaderOptions&);
 
         void clearClient() { m_client = 0; }
 

diff --git a/Source/WebCore/loader/cache/CachedFont.cpp b/Source/WebCore/loader/cache/CachedFont.cpp
index b970428..72358a3 100644 (file)
--- a/Source/WebCore/loader/cache/CachedFont.cpp
+++ b/Source/WebCore/loader/cache/CachedFont.cpp
@@ -70,10 +70,11 @@ CachedFont::~CachedFont()
 #endif
 }
 
-void CachedFont::load(CachedResourceLoader*)
+void CachedFont::load(CachedResourceLoader*, const ResourceLoaderOptions& options)
 {
     // Don't load the file yet.  Wait for an access before triggering the load.
     setLoading(true);
+    m_options = options;
 }
 
 void CachedFont::didAddClient(CachedResourceClient* c)
@@ -97,7 +98,7 @@ void CachedFont::beginLoadIfNeeded(CachedResourceLoader* dl)
 {
     if (!m_loadInitiated) {
         m_loadInitiated = true;
-        CachedResource::load(dl);
+        CachedResource::load(dl, m_options);
     }
 }
 

diff --git a/Source/WebCore/loader/cache/CachedFont.h b/Source/WebCore/loader/cache/CachedFont.h
index 734388a..6d28853 100644 (file)
--- a/Source/WebCore/loader/cache/CachedFont.h
+++ b/Source/WebCore/loader/cache/CachedFont.h
@@ -49,7 +49,7 @@ public:
     CachedFont(const ResourceRequest&);
     virtual ~CachedFont();
     
-    virtual void load(CachedResourceLoader* cachedResourceLoader);
+    virtual void load(CachedResourceLoader*, const ResourceLoaderOptions&);
 
     virtual void didAddClient(CachedResourceClient*);
     virtual void data(PassRefPtr<SharedBuffer> data, bool allDataReceived);

diff --git a/Source/WebCore/loader/cache/CachedImage.cpp b/Source/WebCore/loader/cache/CachedImage.cpp
index 07c4e36..438c9fd 100644 (file)
--- a/Source/WebCore/loader/cache/CachedImage.cpp
+++ b/Source/WebCore/loader/cache/CachedImage.cpp
@@ -81,10 +81,10 @@ void CachedImage::decodedDataDeletionTimerFired(Timer<CachedImage>*)
     destroyDecodedData();
 }
 
-void CachedImage::load(CachedResourceLoader* cachedResourceLoader)
+void CachedImage::load(CachedResourceLoader* cachedResourceLoader, const ResourceLoaderOptions& options)
 {
     if (!cachedResourceLoader || cachedResourceLoader->autoLoadImages())
-        CachedResource::load(cachedResourceLoader, true, DoSecurityCheck);
+        CachedResource::load(cachedResourceLoader, options);
     else
         setLoading(false);
 }

diff --git a/Source/WebCore/loader/cache/CachedImage.h b/Source/WebCore/loader/cache/CachedImage.h
index 537257c..e0f46fb 100644 (file)
--- a/Source/WebCore/loader/cache/CachedImage.h
+++ b/Source/WebCore/loader/cache/CachedImage.h
@@ -42,7 +42,7 @@ public:
     CachedImage(Image*);
     virtual ~CachedImage();
     
-    virtual void load(CachedResourceLoader* cachedResourceLoader);
+    virtual void load(CachedResourceLoader*, const ResourceLoaderOptions&);
 
     Image* image() const; // Returns the nullImage() if the image is not available yet.
     bool hasImage() const { return m_image.get(); }

diff --git a/Source/WebCore/loader/cache/CachedResource.cpp b/Source/WebCore/loader/cache/CachedResource.cpp
index 65918e0..131bb71 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResource.cpp
+++ b/Source/WebCore/loader/cache/CachedResource.cpp
@@ -96,7 +96,6 @@ CachedResource::CachedResource(const ResourceRequest& request, Type type)
     , m_loading(false)
     , m_type(type)
     , m_status(Pending)
-    , m_options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials)
 #ifndef NDEBUG
     , m_deleted(false)
     , m_lruIndex(0)
@@ -131,10 +130,11 @@ CachedResource::~CachedResource()
         m_owningCachedResourceLoader->removeCachedResource(this);
 }
 
-void CachedResource::load(CachedResourceLoader* cachedResourceLoader, bool incremental, SecurityCheckPolicy securityCheck)
+void CachedResource::load(CachedResourceLoader* cachedResourceLoader, const ResourceLoaderOptions& options)
 {
+    m_options = options;
     m_loading = true;
-    m_request = CachedResourceRequest::load(cachedResourceLoader, this, incremental, securityCheck, m_options);
+    m_request = CachedResourceRequest::load(cachedResourceLoader, this, options);
     if (m_request) {
         m_status = Pending;
         cachedResourceLoader->incrementRequestCount(this);

diff --git a/Source/WebCore/loader/cache/CachedResource.h b/Source/WebCore/loader/cache/CachedResource.h
index 2ede689..df06837 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResource.h
+++ b/Source/WebCore/loader/cache/CachedResource.h
@@ -85,9 +85,8 @@ public:
 
     CachedResource(const ResourceRequest&, Type);
     virtual ~CachedResource();
-    
-    virtual void load(CachedResourceLoader* cachedResourceLoader)  { load(cachedResourceLoader, false, DoSecurityCheck); }
-    void load(CachedResourceLoader*, bool incremental, SecurityCheckPolicy);
+
+    virtual void load(CachedResourceLoader*, const ResourceLoaderOptions&);
 
     virtual void setEncoding(const String&) { }
     virtual String encoding() const { return String(); }
@@ -194,8 +193,7 @@ public:
 
     bool wasCanceled() const { return m_status == Canceled; }
     bool errorOccurred() const { return (m_status == LoadError || m_status == DecodeError); }
-    
-    void setResourceLoaderOptions(const ResourceLoaderOptions& options) { m_options = options; }
+
     bool sendResourceLoadCallbacks() const { return m_options.sendLoadCallbacks == SendCallbacks; }
     
     virtual void destroyDecodedData() { }
@@ -242,6 +240,7 @@ protected:
     ResourceRequest m_resourceRequest;
     String m_accept;
     OwnPtr<CachedResourceRequest> m_request;
+    ResourceLoaderOptions m_options;
     ResourceLoadPriority m_loadPriority;
 
     ResourceResponse m_response;
@@ -279,8 +278,6 @@ private:
     unsigned m_type : 3; // Type
     unsigned m_status : 3; // Status
 
-    ResourceLoaderOptions m_options;
-
 #ifndef NDEBUG
     bool m_deleted;
     unsigned m_lruIndex;

diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.cpp b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
index 863fd3d..3d13cc4 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResourceLoader.cpp
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.cpp
@@ -83,6 +83,12 @@ static CachedResource* createResource(CachedResource::Type type, ResourceRequest
     return 0;
 }
 
+static const ResourceLoaderOptions& defaultCachedResourceOptions()
+{
+    static ResourceLoaderOptions options(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, DoSecurityCheck);
+    return options;
+}
+
 CachedResourceLoader::CachedResourceLoader(Document* document)
     : m_document(document)
     , m_requestCount(0)
@@ -133,20 +139,20 @@ CachedImage* CachedResourceLoader::requestImage(ResourceRequest& request)
             return 0;
         }
     }
-    CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String()));
+    CachedImage* resource = static_cast<CachedImage*>(requestResource(CachedResource::ImageResource, request, String(), defaultCachedResourceOptions()));
     if (autoLoadImages() && resource && resource->stillNeedsLoad())
-        resource->load(this);
+        resource->load(this, defaultCachedResourceOptions());
     return resource;
 }
 
 CachedFont* CachedResourceLoader::requestFont(ResourceRequest& request)
 {
-    return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String()));
+    return static_cast<CachedFont*>(requestResource(CachedResource::FontResource, request, String(), defaultCachedResourceOptions()));
 }
 
 CachedCSSStyleSheet* CachedResourceLoader::requestCSSStyleSheet(ResourceRequest& request, const String& charset, ResourceLoadPriority priority)
 {
-    return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, priority));
+    return static_cast<CachedCSSStyleSheet*>(requestResource(CachedResource::CSSStyleSheet, request, charset, defaultCachedResourceOptions(), priority));
 }
 
 CachedCSSStyleSheet* CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequest& request, const String& charset)
@@ -167,8 +173,7 @@ CachedCSSStyleSheet* CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequ
     if (!inCache)
         userSheet->setInCache(true);
 
-    userSheet->setResourceLoaderOptions(ResourceLoaderOptions(DoNotSendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials));
-    userSheet->load(this, /*incremental*/ false, SkipSecurityCheck);
+    userSheet->load(this, ResourceLoaderOptions(DoNotSendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials, SkipSecurityCheck));
 
     if (!inCache)
         userSheet->setInCache(false);
@@ -178,13 +183,13 @@ CachedCSSStyleSheet* CachedResourceLoader::requestUserCSSStyleSheet(ResourceRequ
 
 CachedScript* CachedResourceLoader::requestScript(ResourceRequest& request, const String& charset)
 {
-    return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset));
+    return static_cast<CachedScript*>(requestResource(CachedResource::Script, request, charset, defaultCachedResourceOptions()));
 }
 
 #if ENABLE(XSLT)
 CachedXSLStyleSheet* CachedResourceLoader::requestXSLStyleSheet(ResourceRequest& request)
 {
-    return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String()));
+    return static_cast<CachedXSLStyleSheet*>(requestResource(CachedResource::XSLStyleSheet, request, String(), defaultCachedResourceOptions()));
 }
 #endif
 
@@ -193,7 +198,7 @@ CachedResource* CachedResourceLoader::requestLinkResource(CachedResource::Type t
 {
     ASSERT(frame());
     ASSERT(type == CachedResource::LinkPrefetch || type == CachedResource::LinkPrerender || type == CachedResource::LinkSubresource);
-    return requestResource(type, request, String(), priority);
+    return requestResource(type, request, String(), defaultCachedResourceOptions(), priority);
 }
 #endif
 
@@ -314,7 +319,7 @@ bool CachedResourceLoader::canRequest(CachedResource::Type type, const KURL& url
     return true;
 }
 
-CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, ResourceLoadPriority priority, bool forPreload, const ResourceLoaderOptions& options)
+CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type, ResourceRequest& request, const String& charset, const ResourceLoaderOptions& options, ResourceLoadPriority priority, bool forPreload)
 {
     KURL url = request.url();
     
@@ -352,7 +357,7 @@ CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type,
         resource = loadResource(type, request, charset, priority, options);
         break;
     case Revalidate:
-        resource = revalidateResource(resource, priority);
+        resource = revalidateResource(resource, priority, options);
         break;
     case Use:
         memoryCache()->resourceAccessed(resource);
@@ -369,7 +374,7 @@ CachedResource* CachedResourceLoader::requestResource(CachedResource::Type type,
     return resource;
 }
     
-CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resource, ResourceLoadPriority priority)
+CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resource, ResourceLoadPriority priority, const ResourceLoaderOptions& options)
 {
     ASSERT(resource);
     ASSERT(resource->inCache());
@@ -389,7 +394,7 @@ CachedResource* CachedResourceLoader::revalidateResource(CachedResource* resourc
     memoryCache()->add(newResource);
     
     newResource->setLoadPriority(priority);
-    newResource->load(this);
+    newResource->load(this, options);
 
     if (!urlProtocolIsData)
         m_validatedURLs.add(url);
@@ -412,8 +417,7 @@ CachedResource* CachedResourceLoader::loadResource(CachedResource::Type type, Re
         resource->setInCache(true);
     
     resource->setLoadPriority(priority);
-    resource->setResourceLoaderOptions(options);
-    resource->load(this);
+    resource->load(this, options);
     
     if (!inCache) {
         resource->setOwningCachedResourceLoader(this);
@@ -551,7 +555,7 @@ void CachedResourceLoader::setAutoLoadImages(bool enable)
             CachedImage* image = const_cast<CachedImage*>(static_cast<const CachedImage*>(resource));
 
             if (image->stillNeedsLoad())
-                image->load(this);
+                image->load(this, defaultCachedResourceOptions());
         }
     }
 }
@@ -681,7 +685,7 @@ void CachedResourceLoader::requestPreload(CachedResource::Type type, ResourceReq
     if (type == CachedResource::Script || type == CachedResource::CSSStyleSheet)
         encoding = charset.isEmpty() ? m_document->charset() : charset;
 
-    CachedResource* resource = requestResource(type, request, encoding, ResourceLoadPriorityUnresolved, true);
+    CachedResource* resource = requestResource(type, request, encoding, defaultCachedResourceOptions(), ResourceLoadPriorityUnresolved, true);
     if (!resource || (m_preloads && m_preloads->contains(resource)))
         return;
     resource->increasePreloadCount();

diff --git a/Source/WebCore/loader/cache/CachedResourceLoader.h b/Source/WebCore/loader/cache/CachedResourceLoader.h
index f4094bb..5197395 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResourceLoader.h
+++ b/Source/WebCore/loader/cache/CachedResourceLoader.h
@@ -109,8 +109,8 @@ public:
 private:
     // FIXME: The default value for ResourceLoaderOptions will always be used currently.
     // It is plumbed for http://bugs.webkit.org/show_bug.cgi?id=61225 .
-    CachedResource* requestResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false, const ResourceLoaderOptions& = ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, AllowStoredCredentials, AskClientForCrossOriginCredentials));
-    CachedResource* revalidateResource(CachedResource*, ResourceLoadPriority);
+    CachedResource* requestResource(CachedResource::Type, ResourceRequest&, const String& charset, const ResourceLoaderOptions&, ResourceLoadPriority = ResourceLoadPriorityUnresolved, bool isPreload = false);
+    CachedResource* revalidateResource(CachedResource*, ResourceLoadPriority, const ResourceLoaderOptions&);
     CachedResource* loadResource(CachedResource::Type, ResourceRequest&, const String& charset, ResourceLoadPriority, const ResourceLoaderOptions&);
     void requestPreload(CachedResource::Type, ResourceRequest&, const String& charset);
 

diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.cpp b/Source/WebCore/loader/cache/CachedResourceRequest.cpp
index 4fcff17..fc0a283 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResourceRequest.cpp
+++ b/Source/WebCore/loader/cache/CachedResourceRequest.cpp
@@ -74,10 +74,9 @@ static ResourceRequest::TargetType cachedResourceTypeToTargetType(CachedResource
 }
 #endif
 
-CachedResourceRequest::CachedResourceRequest(CachedResourceLoader* cachedResourceLoader, CachedResource* resource, bool incremental)
+CachedResourceRequest::CachedResourceRequest(CachedResourceLoader* cachedResourceLoader, CachedResource* resource)
     : m_cachedResourceLoader(cachedResourceLoader)
     , m_resource(resource)
-    , m_incremental(incremental)
     , m_multipart(false)
     , m_finishing(false)
 {
@@ -87,9 +86,9 @@ CachedResourceRequest::~CachedResourceRequest()
 {
 }
 
-PassOwnPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoader* cachedResourceLoader, CachedResource* resource, bool incremental, SecurityCheckPolicy securityCheck, const ResourceLoaderOptions& options)
+PassOwnPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoader* cachedResourceLoader, CachedResource* resource, const ResourceLoaderOptions& options)
 {
-    OwnPtr<CachedResourceRequest> request = adoptPtr(new CachedResourceRequest(cachedResourceLoader, resource, incremental));
+    OwnPtr<CachedResourceRequest> request = adoptPtr(new CachedResourceRequest(cachedResourceLoader, resource));
 
     ResourceRequest resourceRequest = resource->resourceRequest();
 #if PLATFORM(CHROMIUM)
@@ -124,7 +123,7 @@ PassOwnPtr<CachedResourceRequest> CachedResourceRequest::load(CachedResourceLoad
     ResourceLoadPriority priority = resource->loadPriority();
     resourceRequest.setPriority(priority);
 
-    RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(cachedResourceLoader->document()->frame(), request.get(), resourceRequest, priority, securityCheck, options);
+    RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(cachedResourceLoader->document()->frame(), request.get(), resourceRequest, priority, options);
     if (!loader || loader->reachedTerminalState()) {
         // FIXME: What if resources in other frames were waiting for this revalidation?
         LOG(ResourceLoading, "Cannot start loading '%s'", resource->url().string().latin1().data());
@@ -271,7 +270,7 @@ void CachedResourceRequest::didReceiveData(SubresourceLoader* loader, const char
         // The resource data will change as the next part is loaded, so we need to make a copy.
         RefPtr<SharedBuffer> copiedData = SharedBuffer::create(data, size);
         m_resource->data(copiedData.release(), true);
-    } else if (m_incremental)
+    } else
         m_resource->data(loader->resourceData(), false);
 }
 

diff --git a/Source/WebCore/loader/cache/CachedResourceRequest.h b/Source/WebCore/loader/cache/CachedResourceRequest.h
index 6f3fe20..cb8ad51 100644 (file)
--- a/Source/WebCore/loader/cache/CachedResourceRequest.h
+++ b/Source/WebCore/loader/cache/CachedResourceRequest.h
@@ -43,13 +43,13 @@ namespace WebCore {
 
     class CachedResourceRequest : private SubresourceLoaderClient {
     public:
-        static PassOwnPtr<CachedResourceRequest> load(CachedResourceLoader*, CachedResource*, bool incremental, SecurityCheckPolicy, const ResourceLoaderOptions&);
+        static PassOwnPtr<CachedResourceRequest> load(CachedResourceLoader*, CachedResource*, const ResourceLoaderOptions&);
         ~CachedResourceRequest();
 
         CachedResourceLoader* cachedResourceLoader() const { return m_cachedResourceLoader; }
 
     private:
-        CachedResourceRequest(CachedResourceLoader*, CachedResource*, bool incremental);
+        CachedResourceRequest(CachedResourceLoader*, CachedResource*);
         virtual void willSendRequest(SubresourceLoader*, ResourceRequest&, const ResourceResponse&);
         virtual void didReceiveResponse(SubresourceLoader*, const ResourceResponse&);
         virtual void didReceiveData(SubresourceLoader*, const char*, int);
@@ -61,7 +61,6 @@ namespace WebCore {
         RefPtr<SubresourceLoader> m_loader;
         CachedResourceLoader* m_cachedResourceLoader;
         CachedResource* m_resource;
-        bool m_incremental;
         bool m_multipart;
         bool m_finishing;
     };

diff --git a/Source/WebCore/loader/icon/IconLoader.cpp b/Source/WebCore/loader/icon/IconLoader.cpp
index 0eb7a80..a7623ac 100644 (file)
--- a/Source/WebCore/loader/icon/IconLoader.cpp
+++ b/Source/WebCore/loader/icon/IconLoader.cpp
@@ -72,7 +72,7 @@ void IconLoader::startLoading()
     ResourceRequest resourceRequest(m_frame->loader()->icon()->url());
     resourceRequest.setPriority(ResourceLoadPriorityLow);
 
-    RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_frame, this, resourceRequest, ResourceLoadPriorityLow, DoSecurityCheck, ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials));
+    RefPtr<SubresourceLoader> loader = resourceLoadScheduler()->scheduleSubresourceLoad(m_frame, this, resourceRequest, ResourceLoadPriorityLow, ResourceLoaderOptions(SendCallbacks, SniffContent, BufferData, DoNotAllowStoredCredentials, DoNotAskClientForCrossOriginCredentials, DoSecurityCheck));
     if (!loader)
         LOG_ERROR("Failed to start load for icon at url %s", m_frame->loader()->icon()->url().string().ascii().data());