Attachment 361724 Details for Bug 194047 – Patch

[patch] Patch

bug-194047-20190212005012.patch (text/plain), 69.50 KB, created by Tadeu Zagallo on 2019-02-11 15:50:43 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Tadeu Zagallo

Created: 2019-02-11 15:50:43 PST

Size: 69.50 KB

patch

obsolete

>Subversion Revision: 241195
>diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog
>index bdeb0105594c4f9682950399859ae2ceeee71c6f..6cd77f2db8ae0573557fc1069c2d68e11c17d616 100644
>--- a/Source/JavaScriptCore/ChangeLog
>+++ b/Source/JavaScriptCore/ChangeLog
>@@ -1,3 +1,27 @@
>+2019-02-11  Tadeu Zagallo  <tzagallo@apple.com>
>+
>+        Integrate JSC bytecode cache with WebKit
>+        https://bugs.webkit.org/show_bug.cgi?id=194047
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add callback to SourceProvider for caching the bytecode.
>+
>+        * parser/SourceProvider.h:
>+        (JSC::SourceProvider::cacheBytecode const):
>+        * runtime/CachedTypes.cpp:
>+        (JSC::CachedVector::decode const):
>+        (JSC::CachedBitVector::decode const):
>+        (JSC::CachedBigInt::decode const):
>+        * runtime/CodeCache.cpp:
>+        (JSC::CodeCache::write):
>+        (JSC::generateUnlinkedCodeBlockForFunctions):
>+        * runtime/CodeCache.h:
>+        (JSC::SourceCodeValue::SourceCodeValue):
>+        (JSC::CodeCacheMap::fetchFromDiskImpl):
>+        * runtime/Completion.cpp:
>+        (JSC::evaluate):
>+
> 2019-02-07  Robin Morisset  <rmorisset@apple.com>
> 
>         Fix Abs(Neg(x)) -> Abs(x) optimization in B3ReduceStrength
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 62ee2e861694c0b62453009c08cf968052c35423..59511099154e123485fd318e8f8a5b3bf70f898f 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,38 @@
>+2019-02-11  Tadeu Zagallo  <tzagallo@apple.com>
>+
>+        Integrate JSC bytecode cache with WebKit
>+        https://bugs.webkit.org/show_bug.cgi?id=194047
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add CachedBytecode to CachedScript.
>+
>+        * WebCore.xcodeproj/project.pbxproj:
>+        * bindings/js/CachedScriptFetcher.cpp:
>+        (WebCore::CachedScriptFetcher::requestScriptWithCache const):
>+        * bindings/js/CachedScriptSourceProvider.h:
>+        * loader/LoaderStrategy.h:
>+        * loader/ResourceLoader.cpp:
>+        (WebCore::ResourceLoader::didRetrieveDerivedDataFromCache):
>+        * loader/ResourceLoader.h:
>+        * loader/ResourceLoaderOptions.h:
>+        * loader/SubresourceLoader.cpp:
>+        (WebCore::SubresourceLoader::didRetrieveDerivedDataFromCache):
>+        * loader/SubresourceLoader.h:
>+        * loader/ThreadableLoader.cpp:
>+        (WebCore::ThreadableLoaderOptions::isolatedCopy const):
>+        * loader/cache/CachedResource.cpp:
>+        (WebCore::CachedResource::load):
>+        * loader/cache/CachedResource.h:
>+        (WebCore::CachedResource::loader const):
>+        (WebCore::CachedResource::webPageID const):
>+        (WebCore::CachedResource::webFrameID const):
>+        (WebCore::CachedResource::didRetrieveDerivedDataFromCache):
>+        * loader/cache/CachedScript.cpp:
>+        (WebCore::CachedScript::cachedBytecode):
>+        (WebCore::CachedScript::didRetrieveDerivedDataFromCache):
>+        * loader/cache/CachedScript.h:
>+
> 2019-02-08  Zalan Bujtas  <zalan@apple.com>
> 
>         [LFC] The used containing block width value is optional
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index ee5f983b7de2577011c3d82307cdfc021cc91e0b..675536708c195a3dca2de332a7381805ad6eed10 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,71 @@
>+2019-02-11  Tadeu Zagallo  <tzagallo@apple.com>
>+
>+        Integrate JSC bytecode cache with WebKit
>+        https://bugs.webkit.org/show_bug.cgi?id=194047
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Revert part of the code deleted in r238933, but change it to retrieve the
>+        derived data synchronously. Otherwise, the bytecode would not be available
>+        in time for execution.
>+
>+        Additionally  a BytecodeCache to the NetworkProcess to generate and store
>+        bytecode for requests.
>+
>+        * NetworkProcess/NetworkConnectionToWebProcess.cpp:
>+        (WebKit::NetworkConnectionToWebProcess::cacheBytecodeForRequest):
>+        * NetworkProcess/NetworkConnectionToWebProcess.h:
>+        * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
>+        * NetworkProcess/NetworkProcess.h:
>+        (WebKit::NetworkProcess::bytecodeCache):
>+        * NetworkProcess/NetworkResourceLoadParameters.cpp:
>+        (WebKit::NetworkResourceLoadParameters::encode const):
>+        (WebKit::NetworkResourceLoadParameters::decode):
>+        * NetworkProcess/NetworkResourceLoadParameters.h:
>+        * NetworkProcess/NetworkResourceLoader.cpp:
>+        (WebKit::NetworkResourceLoader::didReceiveResponse):
>+        (WebKit::NetworkResourceLoader::didRetrieveCacheEntry):
>+        (WebKit::NetworkResourceLoader::processCachedEntryAfterDidReceiveResponse):
>+        * NetworkProcess/NetworkResourceLoader.h:
>+        * NetworkProcess/cache/BytecodeCache.cpp: Added.
>+        (WebKit::BytecodeCache::Plan::Plan):
>+        (WebKit::BytecodeCache::Plan::compile):
>+        (WebKit::BytecodeCache::Thread::Thread):
>+        (WebKit::BytecodeCache::BytecodeCache):
>+        (WebKit::BytecodeCache::~BytecodeCache):
>+        (WebKit::BytecodeCache::cacheBytecodeForRequest):
>+        * NetworkProcess/cache/BytecodeCache.h: Copied from Source/WebCore/bindings/js/CachedScriptSourceProvider.h.
>+        (WebKit::BytecodeCache::create):
>+        * NetworkProcess/cache/NetworkCache.h:
>+        (WebKit::NetworkCache::Cache::salt const):
>+        * NetworkProcess/cocoa/NetworkProcessCocoa.mm:
>+        (WebKit::NetworkProcess::platformInitializeNetworkProcessCocoa):
>+        * NetworkProcess/soup/NetworkProcessSoup.cpp:
>+        (WebKit::NetworkProcess::platformInitializeNetworkProcess):
>+        * Platform/IPC/DerivedData.cpp: Added.
>+        (IPC::DerivedData::encode const):
>+        (IPC::DerivedData::decode):
>+        (IPC::DerivedDataContainer::DerivedDataContainer):
>+        (IPC::DerivedDataContainer::~DerivedDataContainer):
>+        (IPC::DerivedDataContainer::append):
>+        * Platform/IPC/DerivedData.h: Added.
>+        (IPC::DerivedData::DerivedData):
>+        (IPC::DerivedData::isEmpty const):
>+        (IPC::DerivedData::type const):
>+        (IPC::DerivedData::data const):
>+        (IPC::DerivedDataContainer::create):
>+        * Platform/Logging.h:
>+        * Sources.txt:
>+        * WebKit.xcodeproj/project.pbxproj:
>+        * WebProcess/Network/WebLoaderStrategy.cpp:
>+        (WebKit::WebLoaderStrategy::scheduleLoadFromNetworkProcess):
>+        (WebKit::WebLoaderStrategy::cacheBytecodeForScript):
>+        * WebProcess/Network/WebLoaderStrategy.h:
>+        * WebProcess/Network/WebResourceLoader.cpp:
>+        (WebKit::WebResourceLoader::didReceiveResponse):
>+        * WebProcess/Network/WebResourceLoader.h:
>+        * WebProcess/Network/WebResourceLoader.messages.in:
>+
> 2019-02-08  Keith Rollin  <krollin@apple.com>
> 
>         Unreviewed build fix.
>diff --git a/Source/WebKitLegacy/ChangeLog b/Source/WebKitLegacy/ChangeLog
>index 97d73683b1c326494ef14595d44328ef36b34c1f..4109b535b3e372620d28be5dae6fde0290ae291f 100644
>--- a/Source/WebKitLegacy/ChangeLog
>+++ b/Source/WebKitLegacy/ChangeLog
>@@ -1,3 +1,14 @@
>+2019-02-11  Tadeu Zagallo  <tzagallo@apple.com>
>+
>+        Integrate JSC bytecode cache with WebKit
>+        https://bugs.webkit.org/show_bug.cgi?id=194047
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Implement LoaderStrategy's `cacheBytecodeForScript` as no-op.
>+
>+        * WebCoreSupport/WebResourceLoadScheduler.h:
>+
> 2019-01-31  Takashi Komori  <Takashi.Komori@sony.com>
> 
>         [Curl] Remove unnecessary member from NetworkStorageSession.
>diff --git a/Source/JavaScriptCore/parser/SourceProvider.h b/Source/JavaScriptCore/parser/SourceProvider.h
>index 3778bf941ad7fac864d6ca780a06d8289e91ae4c..bd0a7eb1d60caa739cb1dbf589d4ab0c8f647024 100644
>--- a/Source/JavaScriptCore/parser/SourceProvider.h
>+++ b/Source/JavaScriptCore/parser/SourceProvider.h
>@@ -116,6 +116,7 @@ namespace JSC {
>         virtual unsigned hash() const = 0;
>         virtual StringView source() const = 0;
>         virtual const CachedBytecode* cachedBytecode() const { return nullptr; }
>+        virtual void cacheBytecode() const { }
> 
>         StringView getRange(int start, int end) const
>         {
>diff --git a/Source/JavaScriptCore/runtime/CachedTypes.cpp b/Source/JavaScriptCore/runtime/CachedTypes.cpp
>index 4358171e6c33f5dbaea05ec3cfebd1e5c64395d1..668f05e04e1da244c9c083a00ab484ab2b6abca5 100644
>--- a/Source/JavaScriptCore/runtime/CachedTypes.cpp
>+++ b/Source/JavaScriptCore/runtime/CachedTypes.cpp
>@@ -471,6 +471,8 @@ public:
>     template<typename... Args>
>     void decode(Decoder& decoder, Vector<SourceType<T>, InlineCapacity, OverflowHandler>& vector, Args... args) const
>     {
>+        if (!m_size)
>+            return;
>         vector.resizeToFit(m_size);
>         const T* buffer = this->template buffer<T>();
>         for (unsigned i = 0; i < m_size; ++i)
>@@ -746,6 +748,8 @@ public:
> 
>     void decode(Decoder&, BitVector& bitVector) const
>     {
>+        if (!m_size)
>+            return;
>         bitVector.ensureSize(m_size);
>         memcpy(bitVector.bits(), this->buffer(), m_size);
>     }
>@@ -1037,7 +1041,8 @@ public:
>     {
>         JSBigInt* bigInt = JSBigInt::createWithLengthUnchecked(decoder.vm(), m_length);
>         bigInt->setSign(m_sign);
>-        memcpy(bigInt->dataStorage(), this->buffer(), sizeof(JSBigInt::Digit) * m_length);
>+        if (m_length)
>+            memcpy(bigInt->dataStorage(), this->buffer(), sizeof(JSBigInt::Digit) * m_length);
>         return bigInt;
>     }
> 
>diff --git a/Source/JavaScriptCore/runtime/CodeCache.cpp b/Source/JavaScriptCore/runtime/CodeCache.cpp
>index b41e52651f3e7c9f6ecde23ffb9699c89db78657..fab545569b4b119b0fc9543fe0ebf23f39146ead 100644
>--- a/Source/JavaScriptCore/runtime/CodeCache.cpp
>+++ b/Source/JavaScriptCore/runtime/CodeCache.cpp
>@@ -159,8 +159,17 @@ UnlinkedFunctionExecutable* CodeCache::getUnlinkedGlobalFunctionExecutable(VM& v
> 
> void CodeCache::write(VM& vm)
> {
>-    for (const auto& it : m_sourceCode)
>+    for (auto& it : m_sourceCode) {
>+        if (it.value.written)
>+            continue;
>+        it.value.written = true;
>+        UnlinkedCodeBlock* codeBlock = jsDynamicCast<UnlinkedCodeBlock*>(vm, it.value.cell.get());
>+        if (!codeBlock)
>+            continue;
>+        it.key.source().provider().cacheBytecode();
>+        // FIXME: Move `writeCodeBlock` into a custom SourceProvider
>         writeCodeBlock(vm, it.key, it.value);
>+    }
> }
> 
> void generateUnlinkedCodeBlockForFunctions(VM& vm, UnlinkedCodeBlock* unlinkedCodeBlock, const SourceCode& parentSource, DebuggerMode debuggerMode, ParserError& error)
>@@ -170,7 +179,7 @@ void generateUnlinkedCodeBlockForFunctions(VM& vm, UnlinkedCodeBlock* unlinkedCo
>             return;
> 
>         FunctionExecutable* executable = unlinkedExecutable->link(vm, parentSource);
>-        const SourceCode& source = executable->source();
>+        SourceCode source = executable->source();
>         UnlinkedFunctionCodeBlock* unlinkedFunctionCodeBlock = unlinkedExecutable->unlinkedCodeBlockFor(vm, source, constructorKind, debuggerMode, error, unlinkedExecutable->parseMode());
>         if (unlinkedFunctionCodeBlock)
>             generateUnlinkedCodeBlockForFunctions(vm, unlinkedFunctionCodeBlock, source, debuggerMode, error);
>diff --git a/Source/JavaScriptCore/runtime/CodeCache.h b/Source/JavaScriptCore/runtime/CodeCache.h
>index 80c0d95f9ef794952e5fbc683ee56650e0a021af..be44bddee99fe494e1885ca3e7791da6694f889d 100644
>--- a/Source/JavaScriptCore/runtime/CodeCache.h
>+++ b/Source/JavaScriptCore/runtime/CodeCache.h
>@@ -75,14 +75,16 @@ struct SourceCodeValue {
>     {
>     }
> 
>-    SourceCodeValue(VM& vm, JSCell* cell, int64_t age)
>+    SourceCodeValue(VM& vm, JSCell* cell, int64_t age, bool written = false)
>         : cell(vm, cell)
>         , age(age)
>+        , written(written)
>     {
>     }
> 
>     Strong<JSCell> cell;
>     int64_t age;
>+    bool written;
> };
> 
> class CodeCacheMap {
>@@ -154,7 +156,7 @@ public:
>             return nullptr;
> 
>         VERBOSE_LOG("Found cached CodeBlock on disk");
>-        addCache(key, SourceCodeValue(vm, unlinkedCodeBlock, m_age));
>+        addCache(key, SourceCodeValue(vm, unlinkedCodeBlock, m_age, true));
>         return unlinkedCodeBlock;
> #else
>         UNUSED_PARAM(vm);
>diff --git a/Source/JavaScriptCore/runtime/Completion.cpp b/Source/JavaScriptCore/runtime/Completion.cpp
>index 8a875cd7e3b05dc43659f01b70052bc13cc1ae19..a469d224756f0d7d1f9880ba290217046c7d9e9b 100644
>--- a/Source/JavaScriptCore/runtime/Completion.cpp
>+++ b/Source/JavaScriptCore/runtime/Completion.cpp
>@@ -142,6 +142,8 @@ JSValue evaluate(ExecState* exec, const SourceCode& source, JSValue thisValue, N
>         return jsUndefined();
>     }
> 
>+    vm.codeCache()->write(vm);
>+
>     RELEASE_ASSERT(result);
>     return result;
> }
>diff --git a/Source/WebCore/WebCore.xcodeproj/project.pbxproj b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>index 1e8b88343aaecfe2682d199c893d1735cedb8595..2550e53206143db92f9df5b646388c6cfcebb579 100644
>--- a/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>+++ b/Source/WebCore/WebCore.xcodeproj/project.pbxproj
>@@ -3886,7 +3886,7 @@
> 		BCB16C1C0979C3BD00467741 /* CachedImage.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB16C030979C3BD00467741 /* CachedImage.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		BCB16C200979C3BD00467741 /* CachedResource.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB16C070979C3BD00467741 /* CachedResource.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		BCB16C220979C3BD00467741 /* CachedResourceClientWalker.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB16C090979C3BD00467741 /* CachedResourceClientWalker.h */; };
>-		BCB16C240979C3BD00467741 /* CachedScript.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB16C0B0979C3BD00467741 /* CachedScript.h */; };
>+		BCB16C240979C3BD00467741 /* CachedScript.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB16C0B0979C3BD00467741 /* CachedScript.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		BCB16C280979C3BD00467741 /* CachedXSLStyleSheet.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB16C0F0979C3BD00467741 /* CachedXSLStyleSheet.h */; };
> 		BCB16C2A0979C3BD00467741 /* CachedResourceLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB16C110979C3BD00467741 /* CachedResourceLoader.h */; settings = {ATTRIBUTES = (Private, ); }; };
> 		BCB92D4F1293550B00C8387F /* FontBaseline.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB92D4E1293550B00C8387F /* FontBaseline.h */; settings = {ATTRIBUTES = (Private, ); }; };
>diff --git a/Source/WebCore/bindings/js/CachedScriptFetcher.cpp b/Source/WebCore/bindings/js/CachedScriptFetcher.cpp
>index 7c87b23938e433e508c0fb80be9c9e6fde382103..e0f003f0db1b4a8bcb61af3bd8f56d31396e6f39 100644
>--- a/Source/WebCore/bindings/js/CachedScriptFetcher.cpp
>+++ b/Source/WebCore/bindings/js/CachedScriptFetcher.cpp
>@@ -56,6 +56,7 @@ CachedResourceHandle<CachedScript> CachedScriptFetcher::requestScriptWithCache(D
>     options.contentSecurityPolicyImposition = hasKnownNonce ? ContentSecurityPolicyImposition::SkipPolicyCheck : ContentSecurityPolicyImposition::DoPolicyCheck;
>     options.sameOriginDataURLFlag = SameOriginDataURLFlag::Set;
>     options.integrity = WTFMove(integrity);
>+    options.derivedCachedDataTypesToRetrieve = { "bytecode-cache" };
> 
>     auto request = createPotentialAccessControlRequest(sourceURL, document, crossOriginMode, WTFMove(options));
>     request.upgradeInsecureRequestIfNeeded(document);
>diff --git a/Source/WebCore/bindings/js/CachedScriptSourceProvider.h b/Source/WebCore/bindings/js/CachedScriptSourceProvider.h
>index ae444c64536b235ca165746d940a170bc91caeab..a5dbd22bd347cc735e77c9f9bc60b6c81b572a85 100644
>--- a/Source/WebCore/bindings/js/CachedScriptSourceProvider.h
>+++ b/Source/WebCore/bindings/js/CachedScriptSourceProvider.h
>@@ -29,6 +29,8 @@
> #include "CachedResourceHandle.h"
> #include "CachedScript.h"
> #include "CachedScriptFetcher.h"
>+#include "LoaderStrategy.h"
>+#include "PlatformStrategies.h"
> #include <JavaScriptCore/SourceProvider.h>
> 
> namespace WebCore {
>@@ -45,6 +47,14 @@ public:
> 
>     unsigned hash() const override { return m_cachedScript->scriptHash(); }
>     StringView source() const override { return m_cachedScript->script(); }
>+    const JSC::CachedBytecode* cachedBytecode() const override { return &m_cachedScript->cachedBytecode(); }
>+
>+    void cacheBytecode() const override
>+    {
>+        if (m_cachedScript->cachedBytecode().size())
>+            return;
>+        platformStrategies()->loaderStrategy()->cacheBytecodeForScript(*m_cachedScript);
>+    }
> 
> private:
>     CachedScriptSourceProvider(CachedScript* cachedScript, JSC::SourceProviderSourceType sourceType, Ref<CachedScriptFetcher>&& scriptFetcher)
>diff --git a/Source/WebCore/loader/LoaderStrategy.h b/Source/WebCore/loader/LoaderStrategy.h
>index b35c6fb0e2864d5f8efc4b80fac7a3ff0411193e..2ebf0af1b3a2234d20df827a466521a3796de932 100644
>--- a/Source/WebCore/loader/LoaderStrategy.h
>+++ b/Source/WebCore/loader/LoaderStrategy.h
>@@ -35,6 +35,7 @@
> namespace WebCore {
> 
> class CachedResource;
>+class CachedScript;
> class ContentSecurityPolicy;
> class Frame;
> class FrameLoader;
>@@ -73,6 +74,8 @@ public:
>     using PreconnectCompletionHandler = WTF::Function<void(const ResourceError&)>;
>     virtual void preconnectTo(FrameLoader&, const URL&, StoredCredentialsPolicy, PreconnectCompletionHandler&&) = 0;
> 
>+    virtual void cacheBytecodeForScript(const CachedScript&) = 0;
>+
>     virtual void setCaptureExtraNetworkLoadMetricsEnabled(bool) = 0;
> 
>     virtual bool isOnLine() const = 0;
>diff --git a/Source/WebCore/loader/ResourceLoader.cpp b/Source/WebCore/loader/ResourceLoader.cpp
>index 6c2b131cb9a8d26347a0a7c8e5985419e36c5933..499fbc528c071266a33da4e514ac75fcd20455d0 100644
>--- a/Source/WebCore/loader/ResourceLoader.cpp
>+++ b/Source/WebCore/loader/ResourceLoader.cpp
>@@ -816,4 +816,8 @@ bool ResourceLoader::isAlwaysOnLoggingAllowed() const
>     return frameLoader() && frameLoader()->isAlwaysOnLoggingAllowed();
> }
> 
>+void ResourceLoader::didRetrieveDerivedDataFromCache(const String&, SharedBuffer&)
>+{
>+}
>+
> }
>diff --git a/Source/WebCore/loader/ResourceLoader.h b/Source/WebCore/loader/ResourceLoader.h
>index 4c33a50692a38531523abbb398ebfa2f0f67e8bc..c4d7927b66bb47c075a3ba1d7505b1de7e9b252e 100644
>--- a/Source/WebCore/loader/ResourceLoader.h
>+++ b/Source/WebCore/loader/ResourceLoader.h
>@@ -105,6 +105,7 @@ public:
>     virtual void didReceiveBuffer(Ref<SharedBuffer>&&, long long encodedDataLength, DataPayloadType);
>     virtual void didFinishLoading(const NetworkLoadMetrics&);
>     virtual void didFail(const ResourceError&);
>+    virtual void didRetrieveDerivedDataFromCache(const String& type, SharedBuffer&);
> 
>     WEBCORE_EXPORT void didBlockAuthenticationChallenge();
> 
>diff --git a/Source/WebCore/loader/ResourceLoaderOptions.h b/Source/WebCore/loader/ResourceLoaderOptions.h
>index 9e3074da3211d0ee97b8eb2edf49169ec5df2a4a..9a3060c84f004a39bf0e9b7727b78d63d60def90 100644
>--- a/Source/WebCore/loader/ResourceLoaderOptions.h
>+++ b/Source/WebCore/loader/ResourceLoaderOptions.h
>@@ -152,6 +152,7 @@ struct ResourceLoaderOptions : public FetchOptions {
>     Optional<ServiceWorkerRegistrationIdentifier> serviceWorkerRegistrationIdentifier;
> #endif
>     HashSet<HTTPHeaderName, WTF::IntHash<HTTPHeaderName>, WTF::StrongEnumHashTraits<HTTPHeaderName>> httpHeadersToKeep;
>+    Vector<String> derivedCachedDataTypesToRetrieve;
>     Optional<ContentSecurityPolicyResponseHeaders> cspResponseHeaders;
>     unsigned maxRedirectCount { 20 };
> 
>diff --git a/Source/WebCore/loader/SubresourceLoader.cpp b/Source/WebCore/loader/SubresourceLoader.cpp
>index 483ecd3c13d61e69a358eb81cca6e364cc452009..50b34fd00b90dccd0291e8448285d310ba542fe8 100644
>--- a/Source/WebCore/loader/SubresourceLoader.cpp
>+++ b/Source/WebCore/loader/SubresourceLoader.cpp
>@@ -751,6 +751,13 @@ void SubresourceLoader::didCancel(const ResourceError&)
>     notifyDone(LoadCompletionType::Cancel);
> }
> 
>+void SubresourceLoader::didRetrieveDerivedDataFromCache(const String& type, SharedBuffer& buffer)
>+{
>+    if (m_state != Initialized)
>+        return;
>+    m_resource->didRetrieveDerivedDataFromCache(type, buffer);
>+}
>+
> void SubresourceLoader::notifyDone(LoadCompletionType type)
> {
>     if (reachedTerminalState())
>diff --git a/Source/WebCore/loader/SubresourceLoader.h b/Source/WebCore/loader/SubresourceLoader.h
>index 71fe39207eccb7fe2aa62476790331a79f588851..2f6857294fcb92ea8690bc664765cd47ae04d2b9 100644
>--- a/Source/WebCore/loader/SubresourceLoader.h
>+++ b/Source/WebCore/loader/SubresourceLoader.h
>@@ -79,6 +79,7 @@ private:
>     void didFail(const ResourceError&) override;
>     void willCancel(const ResourceError&) override;
>     void didCancel(const ResourceError&) override;
>+    void didRetrieveDerivedDataFromCache(const String& type, SharedBuffer&) override;
>     
>     void updateReferrerPolicy(const String&);
> 
>diff --git a/Source/WebCore/loader/ThreadableLoader.cpp b/Source/WebCore/loader/ThreadableLoader.cpp
>index 2b7bf429dd622fc727e101302effeedd5e4c3847..d53b4ad39bb5c5e3822906f5b99a15991939695c 100644
>--- a/Source/WebCore/loader/ThreadableLoader.cpp
>+++ b/Source/WebCore/loader/ThreadableLoader.cpp
>@@ -89,6 +89,9 @@ ThreadableLoaderOptions ThreadableLoaderOptions::isolatedCopy() const
>     copy.initiatorContext = this->initiatorContext;
>     copy.clientCredentialPolicy = this->clientCredentialPolicy;
>     copy.maxRedirectCount = this->maxRedirectCount;
>+    copy.derivedCachedDataTypesToRetrieve.reserveInitialCapacity(this->derivedCachedDataTypesToRetrieve.size());
>+    for (auto& derivedCachedDataType : this->derivedCachedDataTypesToRetrieve)
>+        copy.derivedCachedDataTypesToRetrieve.uncheckedAppend(derivedCachedDataType.isolatedCopy());
>     copy.preflightPolicy = this->preflightPolicy;
> 
>     // ThreadableLoaderOptions
>diff --git a/Source/WebCore/loader/cache/CachedResource.cpp b/Source/WebCore/loader/cache/CachedResource.cpp
>index d29e4ad1fae0b45faf3e98b2f1c9188d721f8767..da9f70eeeac206ac3a5870595223b0b0de8faece 100644
>--- a/Source/WebCore/loader/cache/CachedResource.cpp
>+++ b/Source/WebCore/loader/cache/CachedResource.cpp
>@@ -310,6 +310,13 @@ void CachedResource::load(CachedResourceLoader& cachedResourceLoader)
>             failBeforeStarting();
>             return;
>         }
>+
>+        auto* frameLoader = m_loader->frameLoader();
>+        auto* frameLoaderClient = frameLoader ? &frameLoader->client() : nullptr;
>+        if (frameLoaderClient) {
>+            m_webPageID = frameLoaderClient->pageID().valueOr(0);
>+            m_webFrameID = frameLoaderClient->frameID().valueOr(0);
>+        }
>         m_status = Pending;
>     });
> }
>diff --git a/Source/WebCore/loader/cache/CachedResource.h b/Source/WebCore/loader/cache/CachedResource.h
>index aa8530d80e1ae2769afb93edfa64342e15ae8517..657170c05d6fd4d021dfb16517120be2c9bd9153 100644
>--- a/Source/WebCore/loader/cache/CachedResource.h
>+++ b/Source/WebCore/loader/cache/CachedResource.h
>@@ -162,7 +162,9 @@ public:
>     void setLoading(bool b) { m_loading = b; }
>     virtual bool stillNeedsLoad() const { return false; }
> 
>-    SubresourceLoader* loader() { return m_loader.get(); }
>+    SubresourceLoader* loader() const { return m_loader.get(); }
>+    uint64_t webPageID() const { return m_webPageID; }
>+    uint64_t webFrameID() const { return m_webFrameID; }
> 
>     bool areAllClientsXMLHttpRequests() const;
> 
>@@ -267,6 +269,8 @@ public:
> 
>     virtual void didSendData(unsigned long long /* bytesSent */, unsigned long long /* totalBytesToBeSent */) { }
> 
>+    virtual void didRetrieveDerivedDataFromCache(const String& /* type */, SharedBuffer&) { }
>+
> #if USE(FOUNDATION) || USE(SOUP)
>     WEBCORE_EXPORT void tryReplaceEncodedData(SharedBuffer&);
> #endif
>@@ -370,6 +374,8 @@ private:
>     bool m_hasUnknownEncoding { false };
>     bool m_switchingClientsToRevalidatedResource { false };
>     bool m_ignoreForRequestCount { false };
>+    uint64_t m_webPageID { 0 };
>+    uint64_t m_webFrameID { 0 };
> 
> #ifndef NDEBUG
>     bool m_deleted { false };
>diff --git a/Source/WebCore/loader/cache/CachedScript.cpp b/Source/WebCore/loader/cache/CachedScript.cpp
>index 1bbd44469207c2466222dd235fa23f9b22fdda67..02ed9b453a05f5807c5120512c23abb96cac230e 100644
>--- a/Source/WebCore/loader/cache/CachedScript.cpp
>+++ b/Source/WebCore/loader/cache/CachedScript.cpp
>@@ -89,6 +89,11 @@ StringView CachedScript::script()
>     return m_script;
> }
> 
>+const JSC::CachedBytecode& CachedScript::cachedBytecode()
>+{
>+    return m_cachedBytecode;
>+}
>+
> unsigned CachedScript::scriptHash()
> {
>     if (m_decodingState == NeverDecoded)
>@@ -103,6 +108,17 @@ void CachedScript::finishLoading(SharedBuffer* data)
>     CachedResource::finishLoading(data);
> }
> 
>+void CachedScript::didRetrieveDerivedDataFromCache(const String& type, SharedBuffer& buffer)
>+{
>+    ASSERT(type == "bytecode-cache");
>+    size_t size = buffer.size();
>+    MallocPtr<uint8_t> memory = MallocPtr<uint8_t>::malloc(size);
>+    for (const auto& it : buffer)
>+        memcpy(memory.get() + it.beginPosition, it.segment->data(), it.segment->size());
>+    m_cachedBytecode = JSC::CachedBytecode { WTFMove(memory), size };
>+    CachedResource::didRetrieveDerivedDataFromCache(type, buffer);
>+}
>+
> void CachedScript::destroyDecodedData()
> {
>     m_script = String();
>diff --git a/Source/WebCore/loader/cache/CachedScript.h b/Source/WebCore/loader/cache/CachedScript.h
>index dd6fbcc3687811df06ec1ce28431f388a3d6003c..7934ddce93669333a3eae2eba59eff555ff6e166 100644
>--- a/Source/WebCore/loader/cache/CachedScript.h
>+++ b/Source/WebCore/loader/cache/CachedScript.h
>@@ -26,6 +26,7 @@
> #pragma once
> 
> #include "CachedResource.h"
>+#include <JavaScriptCore/SourceProvider.h>
> 
> namespace WebCore {
> 
>@@ -37,6 +38,7 @@ public:
>     virtual ~CachedScript();
> 
>     StringView script();
>+    const JSC::CachedBytecode& cachedBytecode();
>     unsigned scriptHash();
> 
> private:
>@@ -48,12 +50,14 @@ private:
>     String encoding() const final;
>     const TextResourceDecoder* textResourceDecoder() const final { return m_decoder.get(); }
>     void finishLoading(SharedBuffer*) final;
>+    void didRetrieveDerivedDataFromCache(const String&, SharedBuffer&) final;
> 
>     void destroyDecodedData() final;
> 
>     void setBodyDataFrom(const CachedResource&) final;
> 
>     String m_script;
>+    JSC::CachedBytecode m_cachedBytecode;
>     unsigned m_scriptHash { 0 };
> 
>     enum DecodingState { NeverDecoded, DataAndDecodedStringHaveSameBytes, DataAndDecodedStringHaveDifferentBytes };
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>index b4d7cb406c69e830c2949f591f872de68a62c3fc..8abaabe9f309233021cf63dc13301a32f6129232 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp
>@@ -568,6 +568,12 @@ WebCore::BlobRegistryImpl& NetworkConnectionToWebProcess::blobRegistry()
>     return m_networkProcess->networkBlobRegistry().blobRegistry();
> }
> 
>+void NetworkConnectionToWebProcess::cacheBytecodeForRequest(const WebCore::ResourceRequest& request, uint64_t webPageID, uint64_t webFrameID)
>+{
>+    if (auto* bytecodeCache = m_networkProcess->bytecodeCache())
>+        bytecodeCache->cacheBytecodeForRequest(request, webPageID, webFrameID);
>+}
>+
> void NetworkConnectionToWebProcess::setCaptureExtraNetworkLoadMetricsEnabled(bool enabled)
> {
>     m_captureExtraNetworkLoadMetricsEnabled = enabled;
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>index a3cae8808c553605888362a7e72ccc698160c343..64b46d4d6a1491b6702b0a96ce5d9493289432af 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h
>@@ -170,6 +170,8 @@ private:
>     void unregisterBlobURL(const URL&);
>     void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&&)>&&);
> 
>+    void cacheBytecodeForRequest(const WebCore::ResourceRequest&, uint64_t, uint64_t);
>+
>     void setCaptureExtraNetworkLoadMetricsEnabled(bool);
> 
>     void createSocketStream(URL&&, PAL::SessionID, String cachePartition, uint64_t);
>diff --git a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>index 67afabb6205e4d3dc9146e4e14179969f0df523f..36163e99f9a86e291a6d0b56ac0de452786707b5 100644
>--- a/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>+++ b/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in
>@@ -50,6 +50,8 @@ messages -> NetworkConnectionToWebProcess LegacyReceiver {
>     BlobSize(URL url) -> (uint64_t resultSize) LegacySync
>     WriteBlobsToTemporaryFiles(Vector<String> blobURLs) -> (Vector<String> fileNames) Async
> 
>+    CacheBytecodeForRequest(WebCore::ResourceRequest request, uint64_t webPageID, uint64_t webFrameID)
>+
>     SetCaptureExtraNetworkLoadMetricsEnabled(bool enabled)
> 
>     CreateSocketStream(URL url, PAL::SessionID sessionID, String cachePartition, uint64_t identifier)
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.h b/Source/WebKit/NetworkProcess/NetworkProcess.h
>index 335c3cafad6716a073695dbb3acc750b2c2c55cd..eefde9dcddf6dd4823188af6da1090d4a8ff1650 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.h
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.h
>@@ -26,6 +26,7 @@
> #pragma once
> 
> #include "AuxiliaryProcess.h"
>+#include "BytecodeCache.h"
> #include "CacheModel.h"
> #include "DownloadManager.h"
> #include "NetworkBlobRegistry.h"
>@@ -134,6 +135,7 @@ public:
> #endif
> 
>     NetworkCache::Cache* cache() { return m_cache.get(); }
>+    BytecodeCache* bytecodeCache() { return m_bytecodeCache.get(); }
> 
>     void setSession(const PAL::SessionID&, Ref<NetworkSession>&&);
>     NetworkSession* networkSession(const PAL::SessionID&) const override;
>@@ -439,6 +441,7 @@ private:
>     HashMap<PAL::SessionID, Ref<CacheStorage::Engine>> m_cacheEngines;
> 
>     RefPtr<NetworkCache::Cache> m_cache;
>+    RefPtr<BytecodeCache> m_bytecodeCache;
> 
>     typedef HashMap<const char*, std::unique_ptr<NetworkProcessSupplement>, PtrHash<const char*>> NetworkProcessSupplementMap;
>     NetworkProcessSupplementMap m_supplements;
>diff --git a/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.cpp b/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.cpp
>index cfe58e1ce9f7b2e23fe87ec70aae6b3b49c9c58f..914e6a6f903398fd3a11361267e4d283f6fde8a6 100644
>--- a/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.cpp
>@@ -80,6 +80,7 @@ void NetworkResourceLoadParameters::encode(IPC::Encoder& encoder) const
>     encoder << needsCertificateInfo;
>     encoder << isMainFrameNavigation;
>     encoder << maximumBufferingTime;
>+    encoder << derivedCachedDataTypesToRetrieve;
> 
>     encoder << static_cast<bool>(sourceOrigin);
>     if (sourceOrigin)
>@@ -171,6 +172,8 @@ bool NetworkResourceLoadParameters::decode(IPC::Decoder& decoder, NetworkResourc
>         return false;
>     if (!decoder.decode(result.maximumBufferingTime))
>         return false;
>+    if (!decoder.decode(result.derivedCachedDataTypesToRetrieve))
>+        return false;
> 
>     bool hasSourceOrigin;
>     if (!decoder.decode(hasSourceOrigin))
>diff --git a/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.h b/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.h
>index b05ff803f17190ade319cda063da031406e4f376..eb7a147a989a5bb30c04ad537e7406c0632a9dfc 100644
>--- a/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.h
>+++ b/Source/WebKit/NetworkProcess/NetworkResourceLoadParameters.h
>@@ -51,6 +51,7 @@ public:
>     Vector<RefPtr<SandboxExtension>> requestBodySandboxExtensions; // Created automatically for the sender.
>     RefPtr<SandboxExtension> resourceSandboxExtension; // Created automatically for the sender.
>     Seconds maximumBufferingTime;
>+    Vector<String> derivedCachedDataTypesToRetrieve;
>     RefPtr<WebCore::SecurityOrigin> sourceOrigin;
>     WebCore::FetchOptions options;
>     Optional<WebCore::ContentSecurityPolicyResponseHeaders> cspResponseHeaders;
>diff --git a/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp b/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>index ee8869548ae294a7ec43ad5014ecb41b75e245bb..ad438111bf7b73d35e4ad564e946cda820504ef6 100644
>--- a/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp
>@@ -27,6 +27,7 @@
> #include "NetworkResourceLoader.h"
> 
> #include "DataReference.h"
>+#include "DerivedData.h"
> #include "FormDataReference.h"
> #include "Logging.h"
> #include "NetworkCache.h"
>@@ -495,7 +496,7 @@ void NetworkResourceLoader::didReceiveResponse(ResourceResponse&& receivedRespon
>     // We wait to receive message NetworkResourceLoader::ContinueDidReceiveResponse before continuing a load for
>     // a main resource because the embedding client must decide whether to allow the load.
>     bool willWaitForContinueDidReceiveResponse = isMainResource();
>-    send(Messages::WebResourceLoader::DidReceiveResponse { response, willWaitForContinueDidReceiveResponse });
>+    send(Messages::WebResourceLoader::DidReceiveResponse { response, willWaitForContinueDidReceiveResponse, { } });
>     if (willWaitForContinueDidReceiveResponse)
>         m_responseCompletionHandler = WTFMove(completionHandler);
>     else
>@@ -826,16 +827,42 @@ void NetworkResourceLoader::didRetrieveCacheEntry(std::unique_ptr<NetworkCache::
>     }
> 
>     bool needsContinueDidReceiveResponseMessage = isMainResource();
>-    send(Messages::WebResourceLoader::DidReceiveResponse { response, needsContinueDidReceiveResponseMessage });
> 
>-    if (needsContinueDidReceiveResponseMessage)
>-        m_cacheEntryWaitingForContinueDidReceiveResponse = WTFMove(entry);
>+    if (!needsContinueDidReceiveResponseMessage)
>+        processCachedEntryAfterDidReceiveResponse(WTFMove(entry));
>     else {
>-        sendResultForCacheEntry(WTFMove(entry));
>-        cleanup(LoadResult::Success);
>+        send(Messages::WebResourceLoader::DidReceiveResponse { response, needsContinueDidReceiveResponseMessage, { } });
>+        m_cacheEntryWaitingForContinueDidReceiveResponse = WTFMove(entry);
>     }
> }
> 
>+void NetworkResourceLoader::processCachedEntryAfterDidReceiveResponse(std::unique_ptr<NetworkCache::Entry> entry)
>+{
>+    if (entry->sourceStorageRecord().bodyHash && !m_parameters.derivedCachedDataTypesToRetrieve.isEmpty()) {
>+        auto bodyHash = *entry->sourceStorageRecord().bodyHash;
>+
>+        Ref<IPC::DerivedDataContainer> derivedData = IPC::DerivedDataContainer::create([loader = makeRef(*this), entry = WTFMove(entry)](const Vector<IPC::DerivedData>&& derivedData) mutable {
>+            loader->send(Messages::WebResourceLoader::DidReceiveResponse { entry->response(), false, derivedData});
>+            loader->sendResultForCacheEntry(WTFMove(entry));
>+            loader->cleanup(LoadResult::Success);
>+        });
>+
>+        for (auto type : m_parameters.derivedCachedDataTypesToRetrieve) {
>+            LOG(NetworkCache, "(NetworkProcess) Retrieving derived data of type \"%s\" for \"%s\"", type.ascii().data(), originalRequest().url().string().ascii().data());
>+            NetworkCache::DataKey key { originalRequest().cachePartition(), type, bodyHash };
>+            m_cache->retrieveData(key, [loader = makeRef(*this), derivedData = derivedData.copyRef(), type] (const uint8_t* data, size_t size) mutable {
>+                if (data)
>+                    derivedData->append(IPC::DerivedData { type, IPC::DataReference { data, size } });
>+            });
>+        }
>+        return;
>+    }
>+
>+    send(Messages::WebResourceLoader::DidReceiveResponse { entry->response(), false, { } });
>+    sendResultForCacheEntry(WTFMove(entry));
>+    cleanup(LoadResult::Success);
>+}
>+
> void NetworkResourceLoader::sendResultForCacheEntry(std::unique_ptr<NetworkCache::Entry> entry)
> {
> #if ENABLE(SHAREABLE_RESOURCE)
>diff --git a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h b/Source/WebKit/NetworkProcess/NetworkResourceLoader.h
>index e7ccb81fb4f9aa4b665941279dd2de976c779eb4..51cfe99d2ba4bcd1daa499382fb7f744cf0a10f7 100644
>--- a/Source/WebKit/NetworkProcess/NetworkResourceLoader.h
>+++ b/Source/WebKit/NetworkProcess/NetworkResourceLoader.h
>@@ -43,6 +43,10 @@ class NetworkStorageSession;
> class ResourceRequest;
> }
> 
>+namespace IPC {
>+class DerivedData;
>+}
>+
> namespace WebKit {
> 
> class NetworkConnectionToWebProcess;
>@@ -131,6 +135,7 @@ private:
>     void sendResultForCacheEntry(std::unique_ptr<NetworkCache::Entry>);
>     void validateCacheEntry(std::unique_ptr<NetworkCache::Entry>);
>     void dispatchWillSendRequestForCacheEntry(WebCore::ResourceRequest&&, std::unique_ptr<NetworkCache::Entry>&&);
>+    void processCachedEntryAfterDidReceiveResponse(std::unique_ptr<NetworkCache::Entry>);
> 
>     bool shouldInterruptLoadForXFrameOptions(const String&, const URL&);
>     bool shouldInterruptLoadForCSPFrameAncestorsOrXFrameOptions(const WebCore::ResourceResponse&);
>@@ -195,8 +200,6 @@ private:
>     bool m_isAllowedToAskUserForCredentials { false };
>     size_t m_numBytesReceived { 0 };
> 
>-    unsigned m_retrievedDerivedDataCount { 0 };
>-
>     WebCore::Timer m_bufferingTimer;
>     RefPtr<NetworkCache::Cache> m_cache;
>     RefPtr<WebCore::SharedBuffer> m_bufferedDataForCache;
>diff --git a/Source/WebKit/NetworkProcess/cache/BytecodeCache.cpp b/Source/WebKit/NetworkProcess/cache/BytecodeCache.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..1fa99925f554063565f450d2d6fdf2d97fad3318
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/cache/BytecodeCache.cpp
>@@ -0,0 +1,185 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "BytecodeCache.h"
>+
>+#include "Logging.h"
>+#include "NetworkCache.h"
>+#include "NetworkProcess.h"
>+#include <JavaScriptCore/Completion.h>
>+#include <JavaScriptCore/JSGlobalObject.h>
>+#include <JavaScriptCore/JSSourceCode.h>
>+#include <JavaScriptCore/ParserError.h>
>+#include <JavaScriptCore/VM.h>
>+#include <WebCore/ResourceRequest.h>
>+#include <wtf/Threading.h>
>+
>+namespace WebKit {
>+
>+class BytecodeCache::Plan : public RefCounted<BytecodeCache::Plan> {
>+    WTF_MAKE_NONCOPYABLE(Plan);
>+    WTF_MAKE_FAST_ALLOCATED;
>+
>+public:
>+    Plan(SHA1::Digest bodyHash, const String& source, const String& url, const String& cachePartition)
>+        : m_bodyHash(bodyHash)
>+        , m_source(source.isolatedCopy())
>+        , m_url(url.isolatedCopy())
>+        , m_cachePartition(cachePartition.isolatedCopy())
>+    {
>+    }
>+
>+    void compile(NetworkCache::Cache* cache, JSC::VM& vm)
>+    {
>+        LOG(BytecodeCache, "[BytecodeCache][Plan] Processing: %s", m_url.ascii().data());
>+
>+        JSC::JSLockHolder locker(vm);
>+        JSC::SourceCode sourceCode = JSC::makeSource(m_source, JSC::SourceOrigin { m_url });
>+        JSC::ParserError error;
>+        JSC::CachedBytecode cachedBytecode = JSC::generateBytecode(vm, sourceCode, error);
>+        if (error.isValid()) {
>+            LOG(BytecodeCache, "[BytecodeCache][Plan] Aborted: error when generating bytecode");
>+            return;
>+        }
>+        RunLoop::main().dispatch([plan = makeRef(*this), cache, cachedBytecode = WTFMove(cachedBytecode)]() {
>+            NetworkCache::DataKey dataKey { plan->m_cachePartition, "bytecode-cache", plan->m_bodyHash };
>+            cache->storeData(dataKey, reinterpret_cast<const uint8_t*>(cachedBytecode.data()), cachedBytecode.size());
>+            LOG(BytecodeCache, "[BytecodeCache][Plan] Stored: %s (%ld bytes)", plan->m_url.ascii().data(), cachedBytecode.size());
>+        });
>+    }
>+
>+private:
>+    SHA1::Digest m_bodyHash;
>+    String m_source;
>+    String m_url;
>+    String m_cachePartition;
>+};
>+
>+class BytecodeCache::Thread : public AutomaticThread {
>+public:
>+    Thread(const AbstractLocker& locker, BytecodeCache& cache)
>+        : AutomaticThread(locker, cache.m_lock, cache.m_condition.copyRef())
>+        , m_cache(cache)
>+    {
>+    }
>+
>+    const char* name() const override
>+    {
>+        return "BytecodeCache Helper Thread";
>+    }
>+
>+protected:
>+    PollResult poll(const AbstractLocker&) override
>+    {
>+        if (m_cache.m_queue.isEmpty())
>+            return PollResult::Wait;
>+
>+        m_plans = WTFMove(m_cache.m_queue);
>+        return PollResult::Work;
>+    }
>+
>+    WorkResult work() override
>+    {
>+        RELEASE_ASSERT(!m_plans.isEmpty());
>+        NetworkCache::Cache* cache = m_cache.m_networkProcess.cache();
>+        if (!cache)
>+            return WorkResult::Stop;
>+
>+        for (const auto& plan : m_plans)
>+            plan->compile(cache, *m_vm);
>+        m_plans.clear();
>+        return WorkResult::Continue;
>+    }
>+
>+protected:
>+    void threadDidStart() override
>+    {
>+        LOG(BytecodeCache, "[BytecodeCache][Thread] Started");
>+        m_vm = JSC::VM::create();
>+        WTF::Thread::current().changePriority(-10);
>+    }
>+
>+    void threadIsStopping(const AbstractLocker&) override
>+    {
>+        JSC::JSLockHolder locker(*m_vm);
>+        m_vm = nullptr;
>+        LOG(BytecodeCache, "[BytecodeCache][Thread] Stopped");
>+    }
>+
>+private:
>+    BytecodeCache& m_cache;
>+    Plans m_plans;
>+    RefPtr<JSC::VM> m_vm;
>+};
>+
>+BytecodeCache::BytecodeCache(NetworkProcess& networkProcess)
>+    : m_networkProcess(networkProcess)
>+    , m_lock(Box<Lock>::create())
>+    , m_condition(AutomaticThreadCondition::create())
>+{
>+    LockHolder locker(*m_lock);
>+    m_thread = adoptRef(new Thread(locker, *this));
>+}
>+
>+BytecodeCache::~BytecodeCache()
>+{
>+}
>+
>+void BytecodeCache::cacheBytecodeForRequest(const WebCore::ResourceRequest& request, uint64_t webPageID, uint64_t webFrameID)
>+{
>+    LOG(BytecodeCache, "[BytecodeCache] Checking: %s", request.url().string().ascii().data());
>+
>+    if (!request.url().protocolIsInHTTPFamily()) {
>+        LOG(BytecodeCache, "[BytecodeCache] Aborted: request in not http(s)");
>+        return;
>+    }
>+
>+    NetworkCache::Cache* cache = m_networkProcess.cache();
>+    if (!cache) {
>+        LOG(BytecodeCache, "[BytecodeCache] Aborted: cache is not available");
>+        return;
>+    }
>+
>+    cache->retrieve(request, { webPageID,  webFrameID }, [bytecodeCache = makeRef(*this), request = WebCore::ResourceRequest { request }](auto entry, auto) {
>+        if (!entry) {
>+            LOG(BytecodeCache, "[BytecodeCache] Aborted: the original request was not cached");
>+            return;
>+        }
>+        const auto& record = entry->sourceStorageRecord();
>+        if (!record.bodyHash) {
>+            LOG(BytecodeCache, "[BytecodeCache] Aborted: record has no bodyHash");
>+            return;
>+        }
>+
>+        LOG(BytecodeCache, "[BytecodeCache] Enqueued plan");
>+        LockHolder locker(*bytecodeCache->m_lock);
>+        String source { record.body.data(), static_cast<unsigned>(record.body.size()) };
>+        bytecodeCache->m_queue.append(adoptRef(*new Plan { *record.bodyHash, WTFMove(source), request.url().string(), request.cachePartition() }));
>+        bytecodeCache->m_condition->notifyAll(locker);
>+    });
>+}
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/cache/BytecodeCache.h b/Source/WebKit/NetworkProcess/cache/BytecodeCache.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..3521c01b7582058b174d4785bfc268c662c8b0bc
>--- /dev/null
>+++ b/Source/WebKit/NetworkProcess/cache/BytecodeCache.h
>@@ -0,0 +1,74 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
>+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
>+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
>+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
>+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
>+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
>+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
>+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
>+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
>+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include <wtf/AutomaticThread.h>
>+#include <wtf/FastMalloc.h>
>+#include <wtf/Lock.h>
>+#include <wtf/Noncopyable.h>
>+#include <wtf/Ref.h>
>+#include <wtf/RefCounted.h>
>+#include <wtf/Vector.h>
>+
>+namespace WebCore {
>+class ResourceRequest;
>+};
>+
>+namespace WebKit {
>+
>+class NetworkProcess;
>+
>+class BytecodeCache : public RefCounted<BytecodeCache> {
>+    WTF_MAKE_NONCOPYABLE(BytecodeCache);
>+    WTF_MAKE_FAST_ALLOCATED;
>+
>+    class Plan;
>+    class Thread;
>+    using Plans = Vector<Ref<Plan>, 8>;
>+
>+    friend class Thread;
>+
>+public:
>+    static Ref<BytecodeCache> create(NetworkProcess& networkProcess)
>+    {
>+        return adoptRef(*new BytecodeCache(networkProcess));
>+    }
>+
>+    ~BytecodeCache();
>+
>+    void cacheBytecodeForRequest(const WebCore::ResourceRequest&, uint64_t, uint64_t);
>+
>+private:
>+    BytecodeCache(NetworkProcess&);
>+
>+    NetworkProcess& m_networkProcess;
>+    Plans m_queue;
>+    Box<Lock> m_lock;
>+    Ref<AutomaticThreadCondition> m_condition;
>+    RefPtr<AutomaticThread> m_thread;
>+};
>+
>+} // namespace WebKit
>diff --git a/Source/WebKit/NetworkProcess/cache/NetworkCache.h b/Source/WebKit/NetworkProcess/cache/NetworkCache.h
>index 3e47861f20f1a7b8cfa6c9e6f9e7450adb6a1ced..d6cc2081ece60464346529197b34e01c4435d3fe 100644
>--- a/Source/WebKit/NetworkProcess/cache/NetworkCache.h
>+++ b/Source/WebKit/NetworkProcess/cache/NetworkCache.h
>@@ -134,6 +134,8 @@ public:
> 
>     void retrieveData(const DataKey&, Function<void(const uint8_t*, size_t)>);
>     void storeData(const DataKey&,  const uint8_t* data, size_t);
>+
>+    const Salt& salt() const { return m_storage->salt(); }
>     
>     std::unique_ptr<Entry> makeEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, RefPtr<WebCore::SharedBuffer>&&);
>     std::unique_ptr<Entry> makeRedirectEntry(const WebCore::ResourceRequest&, const WebCore::ResourceResponse&, const WebCore::ResourceRequest& redirectRequest);
>diff --git a/Source/WebKit/NetworkProcess/cocoa/NetworkProcessCocoa.mm b/Source/WebKit/NetworkProcess/cocoa/NetworkProcessCocoa.mm
>index c306cce43061c4519e2555bdd4f498262f3a1551..626996bf8d44885024a6d3ceaf07f2fa2cb43252 100644
>--- a/Source/WebKit/NetworkProcess/cocoa/NetworkProcessCocoa.mm
>+++ b/Source/WebKit/NetworkProcess/cocoa/NetworkProcessCocoa.mm
>@@ -122,6 +122,7 @@ void NetworkProcess::platformInitializeNetworkProcessCocoa(const NetworkProcessC
> #endif
> 
>     m_cache = NetworkCache::Cache::open(*this, m_diskCacheDirectory, cacheOptions);
>+    m_bytecodeCache = BytecodeCache::create(*this);
>     if (!m_cache)
>         RELEASE_LOG_ERROR(NetworkCache, "Failed to initialize the WebKit network disk cache");
> 
>diff --git a/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp b/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp
>index a0d2af641043ca01eac54538fae40fa30c64efd6..04107c72d5698e421fe499464e09243b13f0062b 100644
>--- a/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp
>+++ b/Source/WebKit/NetworkProcess/soup/NetworkProcessSoup.cpp
>@@ -119,6 +119,7 @@ void NetworkProcess::platformInitializeNetworkProcess(const NetworkProcessCreati
> #endif
> 
>     m_cache = NetworkCache::Cache::open(*this, m_diskCacheDirectory, cacheOptions);
>+    m_bytecodeCache = BytecodeCache::create(*this);
> 
>     supplement<WebCookieManager>()->setHTTPCookieAcceptPolicy(parameters.cookieAcceptPolicy, OptionalCallbackID());
> 
>diff --git a/Source/WebKit/Platform/IPC/DerivedData.cpp b/Source/WebKit/Platform/IPC/DerivedData.cpp
>new file mode 100644
>index 0000000000000000000000000000000000000000..28b8551d13e04caf6caac3de9e3eab8dcfd33470
>--- /dev/null
>+++ b/Source/WebKit/Platform/IPC/DerivedData.cpp
>@@ -0,0 +1,71 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#include "config.h"
>+#include "DerivedData.h"
>+
>+#include "ArgumentCoders.h"
>+#include "Decoder.h"
>+#include "Encoder.h"
>+
>+namespace IPC {
>+
>+void DerivedData::encode(Encoder& encoder) const
>+{
>+    ArgumentCoder<String>::encode(encoder, m_type);
>+    encoder.encode(m_data);
>+}
>+
>+bool DerivedData::decode(Decoder& decoder, DerivedData& derivedData)
>+{
>+    if (!ArgumentCoder<String>::decode(decoder, derivedData.m_type))
>+        return false;
>+    return decoder.decode(derivedData.m_data);
>+}
>+
>+Optional<DerivedData> DerivedData::decode(Decoder& decoder)
>+{
>+    DerivedData derivedData;
>+    if (!decode(decoder, derivedData))
>+        return WTF::nullopt;
>+    return { derivedData };
>+}
>+
>+DerivedDataContainer::DerivedDataContainer(Finalizer&& finalizer)
>+    : m_finalizer(WTFMove(finalizer))
>+{
>+}
>+
>+DerivedDataContainer::~DerivedDataContainer()
>+{
>+    m_finalizer(WTFMove(m_derivedData));
>+}
>+
>+void DerivedDataContainer::append(const DerivedData& derivedData)
>+{
>+    m_derivedData.append(derivedData);
>+}
>+
>+} // namespace IPC
>diff --git a/Source/WebKit/Platform/IPC/DerivedData.h b/Source/WebKit/Platform/IPC/DerivedData.h
>new file mode 100644
>index 0000000000000000000000000000000000000000..4b94ab14e78d863d5ce5122105d229734eeb2fab
>--- /dev/null
>+++ b/Source/WebKit/Platform/IPC/DerivedData.h
>@@ -0,0 +1,85 @@
>+/*
>+ * Copyright (C) 2019 Apple Inc. All rights reserved.
>+ *
>+ * Redistribution and use in source and binary forms, with or without
>+ * modification, are permitted provided that the following conditions
>+ * are met:
>+ * 1. Redistributions of source code must retain the above copyright
>+ *    notice, this list of conditions and the following disclaimer.
>+ * 2. Redistributions in binary form must reproduce the above copyright
>+ *    notice, this list of conditions and the following disclaimer in the
>+ *    documentation and/or other materials provided with the distribution.
>+ *
>+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
>+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
>+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
>+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
>+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
>+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
>+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
>+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
>+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
>+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
>+ * THE POSSIBILITY OF SUCH DAMAGE.
>+ */
>+
>+#pragma once
>+
>+#include "DataReference.h"
>+#include <wtf/CompletionHandler.h>
>+#include <wtf/Optional.h>
>+#include <wtf/text/WTFString.h>
>+
>+namespace IPC {
>+
>+class Decoder;
>+class Encoder;
>+
>+class DerivedData {
>+public:
>+    DerivedData() = default;
>+
>+    DerivedData(const String& type, const IPC::DataReference& data)
>+        : m_type(type)
>+        , m_data(data)
>+    {
>+    }
>+
>+    bool isEmpty() const { return !m_data.size(); }
>+
>+    const String& type() const { return m_type; }
>+    const DataReference& data() const { return m_data; }
>+
>+    void encode(Encoder&) const;
>+    static bool decode(Decoder&, DerivedData&);
>+    static Optional<DerivedData> decode(Decoder&);
>+
>+private:
>+    String m_type;
>+    DataReference m_data;
>+};
>+
>+class DerivedDataContainer : public RefCounted<DerivedDataContainer> {
>+    WTF_MAKE_NONCOPYABLE(DerivedDataContainer);
>+    WTF_MAKE_FAST_ALLOCATED;
>+
>+public:
>+    using Finalizer = CompletionHandler<void(const Vector<DerivedData>&&)>;
>+
>+    static Ref<DerivedDataContainer> create(Finalizer&& finalizer)
>+    {
>+        return adoptRef(*new DerivedDataContainer(WTFMove(finalizer)));
>+    }
>+
>+    ~DerivedDataContainer();
>+
>+    void append(const DerivedData&);
>+
>+private:
>+    DerivedDataContainer(Finalizer&&);
>+
>+    Finalizer m_finalizer;
>+    Vector<DerivedData> m_derivedData;
>+};
>+
>+} // namespace IPC
>diff --git a/Source/WebKit/Platform/Logging.h b/Source/WebKit/Platform/Logging.h
>index 59cee853079300b8b1eb2427c63c610e6d605109..e7f73e49a8f62d5ec6017c22da5429fa61d6a6f6 100644
>--- a/Source/WebKit/Platform/Logging.h
>+++ b/Source/WebKit/Platform/Logging.h
>@@ -43,6 +43,7 @@ extern "C" {
>     M(Automation) \
>     M(ActivityState) \
>     M(BackForward) \
>+    M(BytecodeCache) \
>     M(CacheStorage) \
>     M(ContentObservation) \
>     M(ContextMenu) \
>diff --git a/Source/WebKit/Sources.txt b/Source/WebKit/Sources.txt
>index b39d264c8f8f6576439cdcdaf45c7caa71e5b9be..704dd79f1485bf61ef9a7d06bd7c57be4a0d2dc6 100644
>--- a/Source/WebKit/Sources.txt
>+++ b/Source/WebKit/Sources.txt
>@@ -59,6 +59,7 @@ NetworkProcess/ServiceWorker/WebSWOriginStore.cpp @no-unify
> NetworkProcess/ServiceWorker/WebSWServerConnection.cpp @no-unify
> NetworkProcess/ServiceWorker/WebSWServerToContextConnection.cpp @no-unify
> 
>+NetworkProcess/cache/BytecodeCache.cpp
> NetworkProcess/cache/CacheStorageEngine.cpp
> NetworkProcess/cache/CacheStorageEngineCache.cpp
> NetworkProcess/cache/CacheStorageEngineCaches.cpp
>diff --git a/Source/WebKit/WebKit.xcodeproj/project.pbxproj b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>index 3eacefc54b1bf154185874bc28a6f4743e2609bd..567259eee0cb4805b32d3d50db2334cb40882ffa 100644
>--- a/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>+++ b/Source/WebKit/WebKit.xcodeproj/project.pbxproj
>@@ -123,6 +123,9 @@
> 		0FF24A2D1879E4BC003ABF0C /* RemoteLayerTreeDrawingAreaProxyMessageReceiver.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0FF24A2B1879E4BC003ABF0C /* RemoteLayerTreeDrawingAreaProxyMessageReceiver.cpp */; };
> 		0FF24A2E1879E4BC003ABF0C /* RemoteLayerTreeDrawingAreaProxyMessages.h in Headers */ = {isa = PBXBuildFile; fileRef = 0FF24A2C1879E4BC003ABF0C /* RemoteLayerTreeDrawingAreaProxyMessages.h */; };
> 		0FF264A01A1FF9CC001FE759 /* RemoteLayerTreeScrollingPerformanceData.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F707C791A1FEEA300DA7A45 /* RemoteLayerTreeScrollingPerformanceData.h */; };
>+		14D01A7321FA180600BC54E9 /* BytecodeCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 14D01A7121FA180500BC54E9 /* BytecodeCache.h */; };
>+		14E2809422000A0F003BC57B /* DerivedData.h in Headers */ = {isa = PBXBuildFile; fileRef = 14E28092220009F9003BC57B /* DerivedData.h */; };
>+		14E2809522000A22003BC57B /* DerivedData.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 14E28093220009F9003BC57B /* DerivedData.cpp */; };
> 		15739BBD1B42042D00D258C1 /* WebUserMediaClient.h in Headers */ = {isa = PBXBuildFile; fileRef = 4A410F4919AF7B80002EBAB5 /* WebUserMediaClient.h */; };
> 		1A002D43196B337000B9AD44 /* _WKSessionStateInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A002D42196B337000B9AD44 /* _WKSessionStateInternal.h */; };
> 		1A002D44196B338900B9AD44 /* _WKSessionState.h in Headers */ = {isa = PBXBuildFile; fileRef = 1A002D3F196B329400B9AD44 /* _WKSessionState.h */; settings = {ATTRIBUTES = (Private, ); }; };
>@@ -1927,6 +1930,10 @@
> 		0FF24A2C1879E4BC003ABF0C /* RemoteLayerTreeDrawingAreaProxyMessages.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RemoteLayerTreeDrawingAreaProxyMessages.h; path = DerivedSources/WebKit2/RemoteLayerTreeDrawingAreaProxyMessages.h; sourceTree = BUILT_PRODUCTS_DIR; };
> 		0FF24A2F1879E4FE003ABF0C /* RemoteLayerTreeDrawingAreaProxy.messages.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = RemoteLayerTreeDrawingAreaProxy.messages.in; sourceTree = "<group>"; };
> 		1058C7B1FEA5585E11CA2CBB /* Cocoa.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Cocoa.framework; path = /System/Library/Frameworks/Cocoa.framework; sourceTree = "<absolute>"; };
>+		14D01A7021FA180500BC54E9 /* BytecodeCache.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = BytecodeCache.cpp; sourceTree = "<group>"; };
>+		14D01A7121FA180500BC54E9 /* BytecodeCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BytecodeCache.h; sourceTree = "<group>"; };
>+		14E28092220009F9003BC57B /* DerivedData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DerivedData.h; sourceTree = "<group>"; };
>+		14E28093220009F9003BC57B /* DerivedData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DerivedData.cpp; sourceTree = "<group>"; };
> 		1A002D3E196B329400B9AD44 /* _WKSessionState.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = _WKSessionState.mm; sourceTree = "<group>"; };
> 		1A002D3F196B329400B9AD44 /* _WKSessionState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKSessionState.h; sourceTree = "<group>"; };
> 		1A002D42196B337000B9AD44 /* _WKSessionStateInternal.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKSessionStateInternal.h; sourceTree = "<group>"; };
>@@ -5385,6 +5392,8 @@
> 				1AC7537E183BE50F0072CB15 /* DataReference.h */,
> 				BC032D9D10F437D10058C15A /* Decoder.cpp */,
> 				BC032D9E10F437D10058C15A /* Decoder.h */,
>+				14E28093220009F9003BC57B /* DerivedData.cpp */,
>+				14E28092220009F9003BC57B /* DerivedData.h */,
> 				BC032D9F10F437D10058C15A /* Encoder.cpp */,
> 				BC032DA010F437D10058C15A /* Encoder.h */,
> 				4151E5C31FBB90A900E47E2D /* FormDataReference.h */,
>@@ -8761,6 +8770,8 @@
> 		E489D2821A0A2BE80078C06A /* cache */ = {
> 			isa = PBXGroup;
> 			children = (
>+				14D01A7021FA180500BC54E9 /* BytecodeCache.cpp */,
>+				14D01A7121FA180500BC54E9 /* BytecodeCache.h */,
> 				41897ED61F415D860016FA42 /* CacheStorageEngine.cpp */,
> 				41897ED21F415D850016FA42 /* CacheStorageEngine.h */,
> 				41C858191F510DEE0065E085 /* CacheStorageEngineCache.cpp */,
>@@ -9019,6 +9030,7 @@
> 				E170876C16D6CA6900F99226 /* BlobRegistryProxy.h in Headers */,
> 				4F601432155C5AA2001FBDE0 /* BlockingResponseMap.h in Headers */,
> 				1A5705111BE410E600874AF1 /* BlockSPI.h in Headers */,
>+				14D01A7321FA180600BC54E9 /* BytecodeCache.h in Headers */,
> 				BC3065FA1259344E00E71278 /* CacheModel.h in Headers */,
> 				41897ED81F415D8A0016FA42 /* CacheStorageEngine.h in Headers */,
> 				41FABD2A1F4DE001006A6C97 /* CacheStorageEngineCache.h in Headers */,
>@@ -9039,6 +9051,7 @@
> 				C55F91711C59676E0029E92D /* DataDetectionResult.h in Headers */,
> 				1AC75380183BE50F0072CB15 /* DataReference.h in Headers */,
> 				BC032DA610F437D10058C15A /* Decoder.h in Headers */,
>+				14E2809422000A0F003BC57B /* DerivedData.h in Headers */,
> 				57DCEDAB214C60090016B847 /* DeviceIdentitySPI.h in Headers */,
> 				07297F9F1C17BBEA015F0735 /* DeviceIdHashSaltStorage.h in Headers */,
> 				83891B6C1A68C30B0030F386 /* DiagnosticLoggingClient.h in Headers */,
>@@ -9128,6 +9141,7 @@
> 				413075AD1DE85F580039EC69 /* LibWebRTCSocket.h in Headers */,
> 				41DC459C1E3DBB2800B11F51 /* LibWebRTCSocketClient.h in Headers */,
> 				413075B21DE85F580039EC69 /* LibWebRTCSocketFactory.h in Headers */,
>+				57900B4021F8F9B8008317DE /* LoadOptimizer.h in Headers */,
> 				2D1087611D2C573E00B85F82 /* LoadParameters.h in Headers */,
> 				578DC2982155A0020074E815 /* LocalAuthenticationSoftLink.h in Headers */,
> 				57DCEDAC214C60270016B847 /* LocalAuthenticator.h in Headers */,
>@@ -10766,6 +10780,7 @@
> 				2D92A77D212B6A7100F493FD /* Connection.cpp in Sources */,
> 				2D92A77E212B6A7100F493FD /* DataReference.cpp in Sources */,
> 				2D92A77F212B6A7100F493FD /* Decoder.cpp in Sources */,
>+				14E2809522000A22003BC57B /* DerivedData.cpp in Sources */,
> 				1AB7D6191288B9D900CFD08C /* DownloadProxyMessageReceiver.cpp in Sources */,
> 				1A64229912DD029200CAAE2C /* DrawingAreaMessageReceiver.cpp in Sources */,
> 				1A64230812DD09EB00CAAE2C /* DrawingAreaProxyMessageReceiver.cpp in Sources */,
>diff --git a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp b/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp
>index 506d166a15d0e75934d720e7f8de6152b1705d31..b7b341a0e3e15e52c66a8d8eb8dcbc0ed8703f2c 100644
>--- a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp
>+++ b/Source/WebKit/WebProcess/Network/WebLoaderStrategy.cpp
>@@ -47,6 +47,7 @@
> #include "WebURLSchemeTaskProxy.h"
> #include <WebCore/ApplicationCacheHost.h>
> #include <WebCore/CachedResource.h>
>+#include <WebCore/CachedScript.h>
> #include <WebCore/ContentSecurityPolicy.h>
> #include <WebCore/DiagnosticLoggingClient.h>
> #include <WebCore/DiagnosticLoggingKeys.h>
>@@ -280,6 +281,7 @@ void WebLoaderStrategy::scheduleLoadFromNetworkProcess(ResourceLoader& resourceL
>     loadParameters.defersLoading = resourceLoader.defersLoading();
>     loadParameters.needsCertificateInfo = resourceLoader.shouldIncludeCertificateInfo();
>     loadParameters.maximumBufferingTime = maximumBufferingTime;
>+    loadParameters.derivedCachedDataTypesToRetrieve = resourceLoader.options().derivedCachedDataTypesToRetrieve;
>     loadParameters.options = resourceLoader.options();
>     loadParameters.preflightPolicy = resourceLoader.options().preflightPolicy;
>     loadParameters.isHTTPSUpgradeEnabled = resourceLoader.frame() ? resourceLoader.frame()->settings().HTTPSUpgradeEnabled() : false;
>@@ -664,6 +666,16 @@ void WebLoaderStrategy::didFinishPreconnection(uint64_t preconnectionIdentifier,
>         completionHandler(WTFMove(error));
> }
> 
>+void WebLoaderStrategy::cacheBytecodeForScript(const WebCore::CachedScript& script)
>+{
>+    uint64_t webPageID = script.webPageID();
>+    uint64_t webFrameID = script.webFrameID();
>+    if (!webPageID || !webFrameID)
>+        return;
>+
>+    WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::CacheBytecodeForRequest(script.resourceRequest(), webPageID, webFrameID), 0);
>+}
>+
> bool WebLoaderStrategy::isOnLine() const
> {
>     return m_isOnLine;
>diff --git a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h b/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h
>index 1efc93c02a3ca2b9bf0edf0aa905e5f9bb0d3bd3..799ef77ba033fd58082a9c2b75e605d5292a64fe 100644
>--- a/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h
>+++ b/Source/WebKit/WebProcess/Network/WebLoaderStrategy.h
>@@ -68,6 +68,8 @@ public:
>     void preconnectTo(WebCore::FrameLoader&, const URL&, WebCore::StoredCredentialsPolicy, PreconnectCompletionHandler&&) final;
>     void didFinishPreconnection(uint64_t preconnectionIdentifier, WebCore::ResourceError&&);
> 
>+    void cacheBytecodeForScript(const WebCore::CachedScript&) override;
>+
>     void setCaptureExtraNetworkLoadMetricsEnabled(bool) final;
> 
>     WebResourceLoader* webResourceLoaderForIdentifier(ResourceLoadIdentifier identifier) const { return m_webResourceLoaders.get(identifier); }
>diff --git a/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp b/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp
>index bf88fda3007e164ff38a9522abb81fefd7e9f852..2b77115235d2f68f479e6cbcfb04983929b8dbb9 100644
>--- a/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp
>+++ b/Source/WebKit/WebProcess/Network/WebResourceLoader.cpp
>@@ -27,6 +27,7 @@
> #include "WebResourceLoader.h"
> 
> #include "DataReference.h"
>+#include "DerivedData.h"
> #include "Logging.h"
> #include "NetworkProcessConnection.h"
> #include "NetworkResourceLoaderMessages.h"
>@@ -110,7 +111,7 @@ void WebResourceLoader::didSendData(uint64_t bytesSent, uint64_t totalBytesToBeS
>     m_coreLoader->didSendData(bytesSent, totalBytesToBeSent);
> }
> 
>-void WebResourceLoader::didReceiveResponse(const ResourceResponse& response, bool needsContinueDidReceiveResponseMessage)
>+void WebResourceLoader::didReceiveResponse(const ResourceResponse& response, bool needsContinueDidReceiveResponseMessage, const Vector<IPC::DerivedData>& derivedData)
> {
>     LOG(Network, "(WebProcess) WebResourceLoader::didReceiveResponse for '%s'. Status %d.", m_coreLoader->url().string().latin1().data(), response.httpStatusCode());
>     RELEASE_LOG_IF_ALLOWED("didReceiveResponse: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", status = %d)", m_trackingParameters.pageID, m_trackingParameters.frameID, m_trackingParameters.resourceID, response.httpStatusCode());
>@@ -140,6 +141,10 @@ void WebResourceLoader::didReceiveResponse(const ResourceResponse& response, boo
>     }
> 
>     m_coreLoader->didReceiveResponse(response, WTFMove(policyDecisionCompletionHandler));
>+    for (const auto& entry : derivedData) {
>+        auto buffer = SharedBuffer::create(entry.data().data(), entry.data().size());
>+        m_coreLoader->didRetrieveDerivedDataFromCache(entry.type(), buffer.get());
>+    }
> }
> 
> void WebResourceLoader::didReceiveData(const IPC::DataReference& data, int64_t encodedDataLength)
>diff --git a/Source/WebKit/WebProcess/Network/WebResourceLoader.h b/Source/WebKit/WebProcess/Network/WebResourceLoader.h
>index 7fd7832233a362c23a904fc15ef34ca64a967eae..54f05d921f0ac2795c3d6694a2b6f30d72ccbdc6 100644
>--- a/Source/WebKit/WebProcess/Network/WebResourceLoader.h
>+++ b/Source/WebKit/WebProcess/Network/WebResourceLoader.h
>@@ -33,6 +33,7 @@
> 
> namespace IPC {
> class DataReference;
>+class DerivedData;
> }
> 
> namespace WebCore {
>@@ -76,9 +77,8 @@ private:
> 
>     void willSendRequest(WebCore::ResourceRequest&&, WebCore::ResourceResponse&&);
>     void didSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent);
>-    void didReceiveResponse(const WebCore::ResourceResponse&, bool needsContinueDidReceiveResponseMessage);
>+    void didReceiveResponse(const WebCore::ResourceResponse&, bool needsContinueDidReceiveResponseMessage, const Vector<IPC::DerivedData>&);
>     void didReceiveData(const IPC::DataReference&, int64_t encodedDataLength);
>-    void didRetrieveDerivedData(const String& type, const IPC::DataReference&);
>     void didFinishResourceLoad(const WebCore::NetworkLoadMetrics&);
>     void didFailResourceLoad(const WebCore::ResourceError&);
>     void didBlockAuthenticationChallenge();
>diff --git a/Source/WebKit/WebProcess/Network/WebResourceLoader.messages.in b/Source/WebKit/WebProcess/Network/WebResourceLoader.messages.in
>index 7b93256f036dd042f44ba83a318bb7b6636d41aa..30b03d06d2820c8b76e645c7d2e37fe3f648ebcd 100644
>--- a/Source/WebKit/WebProcess/Network/WebResourceLoader.messages.in
>+++ b/Source/WebKit/WebProcess/Network/WebResourceLoader.messages.in
>@@ -23,7 +23,7 @@
> messages -> WebResourceLoader LegacyReceiver {
>     WillSendRequest(WebCore::ResourceRequest request, WebCore::ResourceResponse redirectResponse)
>     DidSendData(uint64_t bytesSent, uint64_t totalBytesToBeSent)
>-    DidReceiveResponse(WebCore::ResourceResponse response, bool needsContinueDidReceiveResponseMessage)
>+    DidReceiveResponse(WebCore::ResourceResponse response, bool needsContinueDidReceiveResponseMessage, Vector<IPC::DerivedData> data)
>     DidReceiveData(IPC::SharedBufferDataReference data, int64_t encodedDataLength)
>     DidFinishResourceLoad(WebCore::NetworkLoadMetrics networkLoadMetrics)
>     DidFailResourceLoad(WebCore::ResourceError error)
>diff --git a/Source/WebKitLegacy/WebCoreSupport/WebResourceLoadScheduler.h b/Source/WebKitLegacy/WebCoreSupport/WebResourceLoadScheduler.h
>index 55b3697530658214bc979a8792b660726d8296dd..d06f75f06553cef3424a54fc28c96f1dba19b31e 100644
>--- a/Source/WebKitLegacy/WebCoreSupport/WebResourceLoadScheduler.h
>+++ b/Source/WebKitLegacy/WebCoreSupport/WebResourceLoadScheduler.h
>@@ -60,6 +60,8 @@ public:
> 
>     void preconnectTo(WebCore::FrameLoader&, const URL&, WebCore::StoredCredentialsPolicy, PreconnectCompletionHandler&&) final;
> 
>+    void cacheBytecodeForScript(const WebCore::CachedScript&) final { }
>+
>     void setCaptureExtraNetworkLoadMetricsEnabled(bool) final { }
> 
>     bool isSerialLoadingEnabled() const { return m_isSerialLoadingEnabled; }

Actions: View | Formatted Diff | Diff

Attachments on bug 194047: 360620 | 361237 | 361242 | 361724 | 367681 | 369651 | 369724