Changeset 185040 in webkit

Timestamp:

May 31, 2015 4:38:06 AM (9 years ago)

Author:

youenn.fablet@crf.canon.fr

Message:

Async XMLHttpRequest should get access to AppCache resources stored as flat files
​https://bugs.webkit.org/show_bug.cgi?id=138506

Reviewed by Darin Adler.

Source/WebCore:

This patch reads flat file data when DocumentLoader substituteResource delivery timer is fired.
Refactoring to remove ApplicationCacheHost/DocumentLoader friend link.
Added ResourceLoader::deliverResponseAndData helper function, taking a SharedBuffer as input to remove an unneeded copy for flat files (no change for other files).

Test: http/tests/appcache/simple-video-async.html

• loader/DocumentLoader.cpp:

(WebCore::DocumentLoader::substituteResourceDeliveryTimerFired):
(WebCore::DocumentLoader::scheduleArchiveLoad):
(WebCore::DocumentLoader::scheduleSubstituteResourceLoad): Helper function to remove ApplicationCacheHost friend link.

• loader/DocumentLoader.h:
• loader/ResourceLoader.cpp:

(WebCore::ResourceLoader::deliverResponseAndData): Helper function, code mostly moved from DocumentLoader::substituteResourceDeliveryTimerFired.

• loader/ResourceLoader.h:
• loader/SubstituteResource.h:

(WebCore::SubstituteResource::deliver): Introduced to be overriden by ApplicationCacheResource to take care of flat file case.

• loader/appcache/ApplicationCacheHost.cpp:

(WebCore::ApplicationCacheHost::maybeLoadResource):
(WebCore::ApplicationCacheHost::scheduleLoadFallbackResourceFromApplicationCache):

• loader/appcache/ApplicationCacheResource.cpp:

(WebCore::ApplicationCacheResource::deliver): Use SharedBuffer::createWithContentsOfFile to load data stored in flat file.

• loader/appcache/ApplicationCacheResource.h:

LayoutTests:

• http/tests/appcache/resources/simple-video-async.manifest: Added.
• http/tests/appcache/simple-video-async-expected.txt: Added.
• http/tests/appcache/simple-video-async.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/http/tests/appcache/resources/simple-video-async.manifest (added)
• LayoutTests/http/tests/appcache/simple-video-async-expected.txt (added)
• LayoutTests/http/tests/appcache/simple-video-async.html (added)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/loader/DocumentLoader.cpp (modified) (3 diffs)
• Source/WebCore/loader/DocumentLoader.h (modified) (2 diffs)
• Source/WebCore/loader/ResourceLoader.cpp (modified) (1 diff)
• Source/WebCore/loader/ResourceLoader.h (modified) (1 diff)
• Source/WebCore/loader/SubstituteResource.h (modified) (4 diffs)
• Source/WebCore/loader/appcache/ApplicationCacheHost.cpp (modified) (2 diffs)
• Source/WebCore/loader/appcache/ApplicationCacheResource.cpp (modified) (1 diff)
• Source/WebCore/loader/appcache/ApplicationCacheResource.h (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2015-05-31  Youenn Fablet  <youenn.fablet@crf.canon.fr>
+
+        Async XMLHttpRequest should get access to AppCache resources stored as flat files
+        https://bugs.webkit.org/show_bug.cgi?id=138506
+
+        Reviewed by Darin Adler.
+
+        * http/tests/appcache/resources/simple-video-async.manifest: Added.
+        * http/tests/appcache/simple-video-async-expected.txt: Added.
+        * http/tests/appcache/simple-video-async.html: Added.
+
 2015-05-31  Xabier Rodriguez Calvar  <calvaris@igalia.com> and Youenn Fablet <youenn.fablet@crf.canon.fr>
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2015-05-31  Youenn Fablet  <youenn.fablet@crf.canon.fr>
+
+        Async XMLHttpRequest should get access to AppCache resources stored as flat files
+        https://bugs.webkit.org/show_bug.cgi?id=138506
+
+        Reviewed by Darin Adler.
+
+        This patch reads flat file data when DocumentLoader substituteResource delivery timer is fired.
+        Refactoring to remove ApplicationCacheHost/DocumentLoader friend link.
+        Added ResourceLoader::deliverResponseAndData helper function, taking a SharedBuffer as input to remove an unneeded copy for flat files (no change for other files). 
+
+        Test: http/tests/appcache/simple-video-async.html
+
+        * loader/DocumentLoader.cpp:
+        (WebCore::DocumentLoader::substituteResourceDeliveryTimerFired):
+        (WebCore::DocumentLoader::scheduleArchiveLoad):
+        (WebCore::DocumentLoader::scheduleSubstituteResourceLoad): Helper function to remove ApplicationCacheHost friend link.
+        * loader/DocumentLoader.h:
+        * loader/ResourceLoader.cpp:
+        (WebCore::ResourceLoader::deliverResponseAndData): Helper function, code mostly moved from DocumentLoader::substituteResourceDeliveryTimerFired.
+        * loader/ResourceLoader.h:
+        * loader/SubstituteResource.h:
+        (WebCore::SubstituteResource::deliver): Introduced to be overriden by ApplicationCacheResource to take care of flat file case.
+        * loader/appcache/ApplicationCacheHost.cpp:
+        (WebCore::ApplicationCacheHost::maybeLoadResource):
+        (WebCore::ApplicationCacheHost::scheduleLoadFallbackResourceFromApplicationCache):
+        * loader/appcache/ApplicationCacheResource.cpp:
+        (WebCore::ApplicationCacheResource::deliver): Use SharedBuffer::createWithContentsOfFile to load data stored in flat file.
+        * loader/appcache/ApplicationCacheResource.h:
+
 2015-05-31  Xabier Rodriguez Calvar  <calvaris@igalia.com> and Youenn Fablet <youenn.fablet@crf.canon.fr>
 

trunk/Source/WebCore/loader/DocumentLoader.cpp

@@ -1120 +1120 @@
         SubstituteResource* resource = it->value.get();
         
-        if (resource) {
-            SharedBuffer* data = resource->data();
-        
-            loader->didReceiveResponse(resource->response());
-
-            // Calling ResourceLoader::didReceiveResponse can end up cancelling the load,
-            // so we need to check if the loader has reached its terminal state.
-            if (loader->reachedTerminalState())
-                return;
-
-            loader->didReceiveData(data->data(), data->size(), data->size(), DataPayloadWholeResource);
-
-            // Calling ResourceLoader::didReceiveData can end up cancelling the load,
-            // so we need to check if the loader has reached its terminal state.
-            if (loader->reachedTerminalState())
-                return;
-
-            loader->didFinishLoading(0);
-        } else {
+        if (resource)
+            resource->deliver(*loader);
+        else {
             // A null resource means that we should fail the load.
             // FIXME: Maybe we should use another error here - something like "not in cache".
@@ -1166 +1150 @@
 {
     if (ArchiveResource* resource = archiveResourceForURL(request.url())) {
-        m_pendingSubstituteResources.set(loader, resource);
-        deliverSubstituteResourcesAfterDelay();
+        scheduleSubstituteResourceLoad(*loader, *resource);
         return true;
     }
@@ -1189 +1172 @@
 }
 #endif // ENABLE(WEB_ARCHIVE)
+
+void DocumentLoader::scheduleSubstituteResourceLoad(ResourceLoader& loader, SubstituteResource& resource)
+{
+    m_pendingSubstituteResources.set(&loader, &resource);
+    deliverSubstituteResourcesAfterDelay();
+}
 
 void DocumentLoader::addResponse(const ResourceResponse& r)

trunk/Source/WebCore/loader/DocumentLoader.h

@@ -159 +159 @@
         WEBCORE_EXPORT bool scheduleArchiveLoad(ResourceLoader*, const ResourceRequest&);
 #endif
+        void scheduleSubstituteResourceLoad(ResourceLoader&, SubstituteResource&);
 
         // Return the ArchiveResource for the URL only when loading an Archive
@@ -432 +433 @@
         ShouldOpenExternalURLsPolicy m_shouldOpenExternalURLsPolicy { ShouldOpenExternalURLsPolicy::ShouldNotAllow };
 
-        friend class ApplicationCacheHost;  // for substitute resource delivery
         std::unique_ptr<ApplicationCacheHost> m_applicationCacheHost;
 

trunk/Source/WebCore/loader/ResourceLoader.cpp

@@ -165 +165 @@
 }
 
+void ResourceLoader::deliverResponseAndData(const ResourceResponse& response, RefPtr<SharedBuffer>&& buffer)
+{
+    Ref<ResourceLoader> protect(*this);
+
+    didReceiveResponse(response);
+    if (reachedTerminalState())
+        return;
+
+    if (buffer) {
+        unsigned size = buffer->size();
+        didReceiveBuffer(buffer.release(), size, DataPayloadWholeResource);
+        if (reachedTerminalState())
+            return;
+    }
+
+    didFinishLoading(0);
+}
+
 void ResourceLoader::start()
 {

trunk/Source/WebCore/loader/ResourceLoader.h

@@ -65 +65 @@
     virtual bool init(const ResourceRequest&);
 
+    void deliverResponseAndData(const ResourceResponse&, RefPtr<SharedBuffer>&&);
+
 #if PLATFORM(IOS)
     virtual bool startLoading()

trunk/Source/WebCore/loader/SubstituteResource.h

@@ -27 +27 @@
 #define SubstituteResource_h
 
-#include <wtf/RefCounted.h>
-
-#include "URL.h"
+#include "ResourceLoader.h"
 #include "ResourceResponse.h"
 #include "SharedBuffer.h"
-
-#include <wtf/RefPtr.h>
 
 namespace WebCore {
@@ -45 +41 @@
     SharedBuffer* data() const { return m_data.get(); }
 
+    virtual void deliver(ResourceLoader& loader) { loader.deliverResponseAndData(m_response, m_data->copy()); }
+
 protected:
     SubstituteResource(const URL& url, const ResourceResponse& response, PassRefPtr<SharedBuffer> data)
@@ -53 +51 @@
         ASSERT(m_data);
     }
-    
+
 private:
     URL m_url;
@@ -59 +57 @@
     RefPtr<SharedBuffer> m_data;
 };
-    
+
 }
 

trunk/Source/WebCore/loader/appcache/ApplicationCacheHost.cpp

@@ -179 +179 @@
         return false;
 
-    m_documentLoader.m_pendingSubstituteResources.set(loader, resource);
-    m_documentLoader.deliverSubstituteResourcesAfterDelay();
-
+    m_documentLoader.scheduleSubstituteResourceLoad(*loader, *resource);
     return true;
 }
@@ -437 +435 @@
     loader->willSwitchToSubstituteResource();
 
-    m_documentLoader.m_pendingSubstituteResources.set(loader, resource);
-    m_documentLoader.deliverSubstituteResourcesAfterDelay();
+    m_documentLoader.scheduleSubstituteResourceLoad(*loader, *resource);
 
     return true;

trunk/Source/WebCore/loader/appcache/ApplicationCacheResource.cpp

@@ -37 +37 @@
     , m_path(path)
 {
+}
+
+void ApplicationCacheResource::deliver(ResourceLoader& loader)
+{
+    RefPtr<SharedBuffer> buffer;
+    if (m_path.isEmpty())
+        buffer = data()->copy();
+    else
+        buffer = SharedBuffer::createWithContentsOfFile(m_path);
+    loader.deliverResponseAndData(response(), WTF::move(buffer));
 }
 

trunk/Source/WebCore/loader/appcache/ApplicationCacheResource.h

@@ -65 +65 @@
     ApplicationCacheResource(const URL&, const ResourceResponse&, unsigned type, PassRefPtr<SharedBuffer>, const String& path);
 
+    virtual void deliver(ResourceLoader&) override;
+
     unsigned m_type;
     unsigned m_storageID;