Changeset 215263 in webkit

Timestamp:

Apr 12, 2017 3:09:14 AM (7 years ago)

Author:

Antti Koivisto

Message:

Cache small media resources in disk cache
​https://bugs.webkit.org/show_bug.cgi?id=170676
<rdar://problem/31532649>

Reviewed by Andreas Kling.

Source/WebCore:

Test: http/tests/cache/disk-cache/disk-cache-media-small.html

Testing support. Functional changes are in WebKit2.

• html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::mediaPlayerCreateResourceLoader):
(WebCore::HTMLMediaElement::lastMediaResourceLoaderForTesting):

• html/HTMLMediaElement.h:
• loader/MediaResourceLoader.cpp:

(WebCore::MediaResourceLoader::MediaResourceLoader):
(WebCore::MediaResourceLoader::addResponseForTesting):
(WebCore::MediaResource::responseReceived):

• loader/MediaResourceLoader.h:
• platform/network/cocoa/WebCoreNSURLSession.mm:

(-[WebCoreNSURLSessionDataTask resource:receivedResponse:]):

We can now receive cached responses.

• testing/Internals.cpp:

(WebCore::responseSourceToString):
(WebCore::Internals::xhrResponseSource):
(WebCore::Internals::mediaResponseSources):
(WebCore::Internals::mediaResponseContentRanges):

• testing/Internals.h:
• testing/Internals.idl:

Source/WebKit2:

• NetworkProcess/cache/NetworkCache.cpp:

(WebKit::NetworkCache::makeRetrieveDecision):

Allow retrieving media resources.

(WebKit::NetworkCache::expectedTotalResourceSizeFromContentRange):
(WebKit::NetworkCache::expectedTotalResourceSize):
(WebKit::NetworkCache::makeStoreDecision):

Store media resource if we can figure out its total size and it is less than 5MB
(and it is cacheable by the usual rules).

LayoutTests:

• http/tests/cache/disk-cache/disk-cache-media-small-expected.txt: Added.
• http/tests/cache/disk-cache/disk-cache-media-small.html: Added.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/http/tests/cache/disk-cache/disk-cache-media-small-expected.txt (added)
• LayoutTests/http/tests/cache/disk-cache/disk-cache-media-small.html (added)
• LayoutTests/platform/ios/TestExpectations (modified) (1 diff)
• LayoutTests/platform/mac-wk2/TestExpectations (modified) (1 diff)
• Source/WebCore/ChangeLog (modified) (1 diff)
• Source/WebCore/html/HTMLMediaElement.cpp (modified) (1 diff)
• Source/WebCore/html/HTMLMediaElement.h (modified) (4 diffs)
• Source/WebCore/loader/MediaResourceLoader.cpp (modified) (3 diffs)
• Source/WebCore/loader/MediaResourceLoader.h (modified) (3 diffs)
• Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm (modified) (1 diff)
• Source/WebCore/testing/Internals.cpp (modified) (3 diffs)
• Source/WebCore/testing/Internals.h (modified) (1 diff)
• Source/WebCore/testing/Internals.idl (modified) (1 diff)
• Source/WebKit2/ChangeLog (modified) (1 diff)
• Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp (modified) (5 diffs)
• Source/WebKit2/NetworkProcess/cache/NetworkCacheSpeculativeLoadManager.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2017-04-10  Antti Koivisto  <antti@apple.com>
+
+        Cache small media resources in disk cache
+        https://bugs.webkit.org/show_bug.cgi?id=170676
+        <rdar://problem/31532649>
+
+        Reviewed by Andreas Kling.
+
+        * http/tests/cache/disk-cache/disk-cache-media-small-expected.txt: Added.
+        * http/tests/cache/disk-cache/disk-cache-media-small.html: Added.
+
 2017-04-12  Per Arne Vollan  <pvollan@apple.com>
 

trunk/LayoutTests/platform/ios/TestExpectations

@@ -138 +138 @@
 http/tests/media
 imported/w3c/web-platform-tests/html/semantics/embedded-content/media-elements
+http/tests/cache/disk-cache/disk-cache-media-small.html
 
 # No touch events

trunk/LayoutTests/platform/mac-wk2/TestExpectations

@@ -647 +647 @@
 webkit.org/b/170410 fast/images/animated-gif-webkit-transform.html [ Pass Failure ]
 
+# Media loading via network cache requires Sierra or newer.
+[ ElCapitan ] http/tests/cache/disk-cache/disk-cache-media-small.html [ Failure ]
+
 compositing/tiling/non-visible-window-tile-coverage.html [ Pass ]

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2017-04-10  Antti Koivisto  <antti@apple.com>
+
+        Cache small media resources in disk cache
+        https://bugs.webkit.org/show_bug.cgi?id=170676
+        <rdar://problem/31532649>
+
+        Reviewed by Andreas Kling.
+
+        Test: http/tests/cache/disk-cache/disk-cache-media-small.html
+
+        Testing support. Functional changes are in WebKit2.
+
+        * html/HTMLMediaElement.cpp:
+        (WebCore::HTMLMediaElement::mediaPlayerCreateResourceLoader):
+        (WebCore::HTMLMediaElement::lastMediaResourceLoaderForTesting):
+        * html/HTMLMediaElement.h:
+        * loader/MediaResourceLoader.cpp:
+        (WebCore::MediaResourceLoader::MediaResourceLoader):
+        (WebCore::MediaResourceLoader::addResponseForTesting):
+        (WebCore::MediaResource::responseReceived):
+        * loader/MediaResourceLoader.h:
+        * platform/network/cocoa/WebCoreNSURLSession.mm:
+        (-[WebCoreNSURLSessionDataTask resource:receivedResponse:]):
+
+            We can now receive cached responses.
+
+        * testing/Internals.cpp:
+        (WebCore::responseSourceToString):
+        (WebCore::Internals::xhrResponseSource):
+        (WebCore::Internals::mediaResponseSources):
+        (WebCore::Internals::mediaResponseContentRanges):
+        * testing/Internals.h:
+        * testing/Internals.idl:
+
 2017-04-12  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebCore/html/HTMLMediaElement.cpp

@@ -6514 +6514 @@
 RefPtr<PlatformMediaResourceLoader> HTMLMediaElement::mediaPlayerCreateResourceLoader()
 {
-    return adoptRef(*new MediaResourceLoader(document(), *this, crossOrigin()));
+    auto mediaResourceLoader = adoptRef(*new MediaResourceLoader(document(), *this, crossOrigin()));
+
+    m_lastMediaResourceLoaderForTesting = mediaResourceLoader->createWeakPtr();
+
+    return WTFMove(mediaResourceLoader);
+}
+
+const MediaResourceLoader* HTMLMediaElement::lastMediaResourceLoaderForTesting() const
+{
+    return m_lastMediaResourceLoaderForTesting.get();
 }
 

trunk/Source/WebCore/html/HTMLMediaElement.h

@@ -39 +39 @@
 #include "UserInterfaceLayoutDirection.h"
 #include "VisibilityChangeClient.h"
+#include <wtf/WeakPtr.h>
 
 #if ENABLE(VIDEO_TRACK)
@@ -74 +75 @@
 class MediaKeys;
 class MediaPlayer;
+class MediaResourceLoader;
 class MediaSession;
 class MediaSource;
@@ -501 +503 @@
 
     void isVisibleInViewportChanged();
+
+    WEBCORE_EXPORT const MediaResourceLoader* lastMediaResourceLoaderForTesting() const;
 
 protected:
@@ -1034 +1038 @@
     std::unique_ptr<DisplaySleepDisabler> m_sleepDisabler;
 
+    WeakPtr<const MediaResourceLoader> m_lastMediaResourceLoaderForTesting;
+
     friend class TrackDisplayUpdateScope;
 

trunk/Source/WebCore/loader/MediaResourceLoader.cpp

@@ -46 +46 @@
     , m_mediaElement(&mediaElement)
     , m_crossOriginMode(crossOriginMode)
+    , m_weakFactory(this)
 {
 }
@@ -95 +96 @@
     ASSERT(m_resources.contains(&mediaResource));
     m_resources.remove(&mediaResource);
+}
+
+void MediaResourceLoader::addResponseForTesting(const ResourceResponse& response)
+{
+    const auto maximumResponsesForTesting = 5;
+    if (m_responsesForTesting.size() > maximumResponsesForTesting)
+        return;
+    m_responsesForTesting.append(response);
 }
 
@@ -152 +161 @@
     if (m_client)
         m_client->responseReceived(*this, response);
+
+    m_loader->addResponseForTesting(response);
 }
 

trunk/Source/WebCore/loader/MediaResourceLoader.h

@@ -32 +32 @@
 #include "ContextDestructionObserver.h"
 #include "PlatformMediaResourceLoader.h"
+#include "ResourceResponse.h"
 #include <wtf/HashSet.h>
 #include <wtf/Ref.h>
+#include <wtf/WeakPtr.h>
 #include <wtf/text/WTFString.h>
 
@@ -54 +56 @@
     const String& crossOriginMode() const { return m_crossOriginMode; }
 
+    Vector<ResourceResponse> responsesForTesting() const { return m_responsesForTesting; }
+    void addResponseForTesting(const ResourceResponse&);
+
+    WeakPtr<const MediaResourceLoader> createWeakPtr() const { return m_weakFactory.createWeakPtr(); }
+
 private:
     void contextDestroyed() override;
@@ -61 +68 @@
     String m_crossOriginMode;
     HashSet<MediaResource*> m_resources;
+    WeakPtrFactory<const MediaResourceLoader> m_weakFactory;
+    Vector<ResourceResponse> m_responsesForTesting;
 };
 

trunk/Source/WebCore/platform/network/cocoa/WebCoreNSURLSession.mm

@@ -552 +552 @@
 - (void)resource:(PlatformMediaResource&)resource receivedResponse:(const ResourceResponse&)response
 {
-    ASSERT(response.source() == ResourceResponse::Source::Network);
+    ASSERT(response.source() == ResourceResponse::Source::Network || response.source() == ResourceResponse::Source::DiskCache || response.source() == ResourceResponse::Source::DiskCacheAfterValidation);
     ASSERT_UNUSED(resource, &resource == _resource);
     ASSERT(isMainThread());

trunk/Source/WebCore/testing/Internals.cpp

@@ -93 +93 @@
 #include "MediaPlayer.h"
 #include "MediaProducer.h"
+#include "MediaResourceLoader.h"
 #include "MediaStreamTrack.h"
 #include "MemoryCache.h"
@@ -603 +604 @@
 }
 
-String Internals::xhrResponseSource(XMLHttpRequest& request)
-{
-    if (request.resourceResponse().isNull())
+static String responseSourceToString(const ResourceResponse& response)
+{
+    if (response.isNull())
         return "Null response";
-    switch (request.resourceResponse().source()) {
+    switch (response.source()) {
     case ResourceResponse::Source::Unknown:
         return "Unknown";
@@ -623 +624 @@
     ASSERT_NOT_REACHED();
     return "Error";
+}
+
+String Internals::xhrResponseSource(XMLHttpRequest& request)
+{
+    return responseSourceToString(request.resourceResponse());
+}
+
+Vector<String> Internals::mediaResponseSources(HTMLMediaElement& media)
+{
+    auto* resourceLoader = media.lastMediaResourceLoaderForTesting();
+    if (!resourceLoader)
+        return { };
+    Vector<String> result;
+    auto responses = resourceLoader->responsesForTesting();
+    for (auto& response : responses)
+        result.append(responseSourceToString(response));
+    return result;
+}
+
+Vector<String> Internals::mediaResponseContentRanges(HTMLMediaElement& media)
+{
+    auto* resourceLoader = media.lastMediaResourceLoaderForTesting();
+    if (!resourceLoader)
+        return { };
+    Vector<String> result;
+    auto responses = resourceLoader->responsesForTesting();
+    for (auto& response : responses)
+        result.append(response.httpHeaderField(HTTPHeaderName::ContentRange));
+    return result;
 }
 

trunk/Source/WebCore/testing/Internals.h

@@ -103 +103 @@
     bool isLoadingFromMemoryCache(const String& url);
     String xhrResponseSource(XMLHttpRequest&);
+    Vector<String> mediaResponseSources(HTMLMediaElement&);
+    Vector<String> mediaResponseContentRanges(HTMLMediaElement&);
     bool isSharingStyleSheetContents(HTMLLinkElement&, HTMLLinkElement&);
     bool isStyleSheetLoadingSubresources(HTMLLinkElement&);

trunk/Source/WebCore/testing/Internals.idl

@@ -98 +98 @@
     boolean isLoadingFromMemoryCache(DOMString url);
     DOMString xhrResponseSource(XMLHttpRequest xhr);
+    sequence<DOMString> mediaResponseSources(HTMLMediaElement media);
+    sequence<DOMString> mediaResponseContentRanges(HTMLMediaElement media);
     boolean isSharingStyleSheetContents(HTMLLinkElement a, HTMLLinkElement b);
     boolean isStyleSheetLoadingSubresources(HTMLLinkElement link);

trunk/Source/WebKit2/ChangeLog

@@ +1 @@
+2017-04-10  Antti Koivisto  <antti@apple.com>
+
+        Cache small media resources in disk cache
+        https://bugs.webkit.org/show_bug.cgi?id=170676
+        <rdar://problem/31532649>
+
+        Reviewed by Andreas Kling.
+
+        * NetworkProcess/cache/NetworkCache.cpp:
+        (WebKit::NetworkCache::makeRetrieveDecision):
+
+            Allow retrieving media resources.
+
+        (WebKit::NetworkCache::expectedTotalResourceSizeFromContentRange):
+        (WebKit::NetworkCache::expectedTotalResourceSize):
+        (WebKit::NetworkCache::makeStoreDecision):
+
+            Store media resource if we can figure out its total size and it is less than 5MB
+            (and it is cacheable by the usual rules).
+
 2017-04-12  Alex Christensen  <achristensen@webkit.org>
 

trunk/Source/WebKit2/NetworkProcess/cache/NetworkCache.cpp

@@ -213 +213 @@
     if (request.httpMethod() != "GET")
         return RetrieveDecision::NoDueToHTTPMethod;
-    if (request.requester() == WebCore::ResourceRequest::Requester::Media)
-        return RetrieveDecision::NoDueToStreamingMedia;
     if (request.cachePolicy() == WebCore::ReloadIgnoringCacheData && !request.isConditional())
         return RetrieveDecision::NoDueToReloadIgnoringCache;
@@ -230 +228 @@
 }
 
-static StoreDecision makeStoreDecision(const WebCore::ResourceRequest& originalRequest, const WebCore::ResourceResponse& response)
+static std::optional<size_t> expectedTotalResourceSizeFromContentRange(const WebCore::ResourceResponse& response)
+{
+    ASSERT(response.httpStatusCode() == 206);
+
+    auto contentRange = response.httpHeaderField(WebCore::HTTPHeaderName::ContentRange);
+    if (contentRange.isNull())
+        return { };
+
+    if (!contentRange.startsWith("bytes "))
+        return { };
+
+    auto slashPosition = contentRange.find('/');
+    if (slashPosition == notFound)
+        return { };
+
+    auto sizeStringLength = contentRange.length() - slashPosition - 1;
+    if (!sizeStringLength)
+        return { };
+
+    bool isValid;
+    auto size = StringView(contentRange).right(sizeStringLength).toIntStrict(isValid);
+    if (!isValid)
+        return { };
+
+    return size;
+}
+
+static StoreDecision makeStoreDecision(const WebCore::ResourceRequest& originalRequest, const WebCore::ResourceResponse& response, size_t bodySize)
 {
     if (!originalRequest.url().protocolIsInHTTPFamily() || !response.isHTTP())
@@ -264 +289 @@
     }
 
-    // Media loaded via XHR is likely being used for MSE streaming (YouTube and Netflix for example).
     // Streaming media fills the cache quickly and is unlikely to be reused.
     // FIXME: We should introduce a separate media cache partition that doesn't affect other resources.
     // FIXME: We should also make sure make the MSE paths are copy-free so we can use mapped buffers from disk effectively.
     auto requester = originalRequest.requester();
-    bool isDefinitelyStreamingMedia = requester == WebCore::ResourceRequest::Requester::Media;
+    bool isDefinitelyMedia = requester == WebCore::ResourceRequest::Requester::Media;
+    if (isDefinitelyMedia) {
+        // Allow caching of smaller media files if we know the total size.
+        const size_t maximumCacheableMediaSize = 5 * 1024 * 1024;
+        auto totalSize = response.httpStatusCode() == 206 ? expectedTotalResourceSizeFromContentRange(response) : bodySize;
+        if (!totalSize || *totalSize > maximumCacheableMediaSize)
+            return StoreDecision::NoDueToStreamingMedia;
+    }
+
     bool isLikelyStreamingMedia = requester == WebCore::ResourceRequest::Requester::XHR && isMediaMIMEType(response.mimeType());
-    if (isLikelyStreamingMedia || isDefinitelyStreamingMedia)
+    if (isLikelyStreamingMedia) {
+        // Media loaded via XHR is likely being used for MSE streaming (YouTube and Netflix for example).
+        // We have no way of knowing the total media size so disallow caching.
         return StoreDecision::NoDueToStreamingMedia;
+    }
 
     return StoreDecision::Yes;
@@ -375 +410 @@
     LOG(NetworkCache, "(NetworkProcess) storing %s, partition %s", request.url().string().latin1().data(), makeCacheKey(request).partition().latin1().data());
 
-    StoreDecision storeDecision = makeStoreDecision(request, response);
+    StoreDecision storeDecision = makeStoreDecision(request, response, responseData ? responseData->size() : 0);
     if (storeDecision != StoreDecision::Yes) {
         LOG(NetworkCache, "(NetworkProcess) didn't store, storeDecision=%d", static_cast<int>(storeDecision));
@@ -419 +454 @@
     LOG(NetworkCache, "(NetworkProcess) storing redirect %s -> %s", request.url().string().latin1().data(), redirectRequest.url().string().latin1().data());
 
-    StoreDecision storeDecision = makeStoreDecision(request, response);
+    StoreDecision storeDecision = makeStoreDecision(request, response, 0);
     if (storeDecision != StoreDecision::Yes) {
         LOG(NetworkCache, "(NetworkProcess) didn't store redirect, storeDecision=%d", static_cast<int>(storeDecision));

trunk/Source/WebKit2/NetworkProcess/cache/NetworkCacheSpeculativeLoadManager.cpp

@@ -365 +365 @@
     if (request.httpMethod() != "GET")
         return;
+    if (!request.httpHeaderField(HTTPHeaderName::Range).isEmpty())
+        return;
 
     auto isMainResource = request.requester() == ResourceRequest::Requester::Main;