31ec94da1fab6e2e9fd9e271123c3fcfe9d3c91f
[WebKit-https.git] / Source / WebKit / NetworkProcess / cache / NetworkCacheSpeculativeLoad.cpp
1 /*
2  * Copyright (C) 2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27
28 #if ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)
29 #include "NetworkCacheSpeculativeLoad.h"
30
31 #include "Logging.h"
32 #include "NetworkCache.h"
33 #include "NetworkLoad.h"
34 #include "NetworkSession.h"
35 #include "SessionTracker.h"
36 #include <pal/SessionID.h>
37 #include <wtf/CurrentTime.h>
38 #include <wtf/RunLoop.h>
39
40 namespace WebKit {
41 namespace NetworkCache {
42
43 using namespace WebCore;
44
45 SpeculativeLoad::SpeculativeLoad(Cache& cache, const GlobalFrameID& frameID, const ResourceRequest& request, std::unique_ptr<NetworkCache::Entry> cacheEntryForValidation, RevalidationCompletionHandler&& completionHandler)
46     : m_cache(cache)
47     , m_frameID(frameID)
48     , m_completionHandler(WTFMove(completionHandler))
49     , m_originalRequest(request)
50     , m_bufferedDataForCache(SharedBuffer::create())
51     , m_cacheEntry(WTFMove(cacheEntryForValidation))
52 {
53     ASSERT(!m_cacheEntry || m_cacheEntry->needsValidation());
54
55     NetworkLoadParameters parameters;
56     parameters.sessionID = PAL::SessionID::defaultSessionID();
57     parameters.storedCredentialsPolicy = StoredCredentialsPolicy::Use;
58     parameters.contentSniffingPolicy = DoNotSniffContent;
59     parameters.contentEncodingSniffingPolicy = ContentEncodingSniffingPolicy::Sniff;
60     parameters.request = m_originalRequest;
61     m_networkLoad = std::make_unique<NetworkLoad>(*this, WTFMove(parameters), *SessionTracker::networkSession(PAL::SessionID::defaultSessionID()));
62 }
63
64 SpeculativeLoad::~SpeculativeLoad()
65 {
66     ASSERT(!m_networkLoad);
67 }
68
69 void SpeculativeLoad::willSendRedirectedRequest(ResourceRequest&& request, ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
70 {
71     LOG(NetworkCacheSpeculativePreloading, "Speculative redirect %s -> %s", request.url().string().utf8().data(), redirectRequest.url().string().utf8().data());
72
73     m_cacheEntry = m_cache->storeRedirect(request, redirectResponse, redirectRequest);
74     // Create a synthetic cache entry if we can't store.
75     if (!m_cacheEntry)
76         m_cacheEntry = m_cache->makeRedirectEntry(request, redirectResponse, redirectRequest);
77
78     // Don't follow the redirect. The redirect target will be registered for speculative load when it is loaded.
79     didComplete();
80 }
81
82 auto SpeculativeLoad::didReceiveResponse(ResourceResponse&& receivedResponse) -> ShouldContinueDidReceiveResponse
83 {
84     m_response = receivedResponse;
85
86     if (m_response.isMultipart())
87         m_bufferedDataForCache = nullptr;
88
89     bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified
90     if (validationSucceeded && m_cacheEntry)
91         m_cacheEntry = m_cache->update(m_originalRequest, m_frameID, *m_cacheEntry, m_response);
92     else
93         m_cacheEntry = nullptr;
94
95     return ShouldContinueDidReceiveResponse::Yes;
96 }
97
98 void SpeculativeLoad::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)
99 {
100     ASSERT(!m_cacheEntry);
101
102     if (m_bufferedDataForCache) {
103         // Prevent memory growth in case of streaming data.
104         const size_t maximumCacheBufferSize = 10 * 1024 * 1024;
105         if (m_bufferedDataForCache->size() + buffer->size() <= maximumCacheBufferSize)
106             m_bufferedDataForCache->append(buffer.get());
107         else
108             m_bufferedDataForCache = nullptr;
109     }
110 }
111
112 void SpeculativeLoad::didFinishLoading(const WebCore::NetworkLoadMetrics&)
113 {
114     if (m_didComplete)
115         return;
116     if (!m_cacheEntry && m_bufferedDataForCache) {
117         m_cacheEntry = m_cache->store(m_originalRequest, m_response, m_bufferedDataForCache.copyRef(), [](auto& mappedBody) { });
118         // Create a synthetic cache entry if we can't store.
119         if (!m_cacheEntry && isStatusCodeCacheableByDefault(m_response.httpStatusCode()))
120             m_cacheEntry = m_cache->makeEntry(m_originalRequest, m_response, WTFMove(m_bufferedDataForCache));
121     }
122
123     didComplete();
124 }
125
126 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
127 void SpeculativeLoad::canAuthenticateAgainstProtectionSpaceAsync(const WebCore::ProtectionSpace&)
128 {
129     m_networkLoad->continueCanAuthenticateAgainstProtectionSpace(false);
130 }
131 #endif
132
133 void SpeculativeLoad::didFailLoading(const ResourceError&)
134 {
135     if (m_didComplete)
136         return;
137     m_cacheEntry = nullptr;
138
139     didComplete();
140 }
141
142 void SpeculativeLoad::didComplete()
143 {
144     RELEASE_ASSERT(RunLoop::isMain());
145
146     if (m_didComplete)
147         return;
148     m_didComplete = true;
149     m_networkLoad = nullptr;
150
151     // Make sure speculatively revalidated resources do not get validated by the NetworkResourceLoader again.
152     if (m_cacheEntry)
153         m_cacheEntry->setNeedsValidation(false);
154
155     m_completionHandler(WTFMove(m_cacheEntry));
156 }
157
158 } // namespace NetworkCache
159 } // namespace WebKit
160
161 #endif // ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)