Shrink various loading-related enums to shrink CachedResource
[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/RunLoop.h>
38
39 namespace WebKit {
40 namespace NetworkCache {
41
42 using namespace WebCore;
43
44 SpeculativeLoad::SpeculativeLoad(Cache& cache, const GlobalFrameID& frameID, const ResourceRequest& request, std::unique_ptr<NetworkCache::Entry> cacheEntryForValidation, RevalidationCompletionHandler&& completionHandler)
45     : m_cache(cache)
46     , m_frameID(frameID)
47     , m_completionHandler(WTFMove(completionHandler))
48     , m_originalRequest(request)
49     , m_bufferedDataForCache(SharedBuffer::create())
50     , m_cacheEntry(WTFMove(cacheEntryForValidation))
51 {
52     ASSERT(!m_cacheEntry || m_cacheEntry->needsValidation());
53
54     NetworkLoadParameters parameters;
55     parameters.sessionID = PAL::SessionID::defaultSessionID();
56     parameters.storedCredentialsPolicy = StoredCredentialsPolicy::Use;
57     parameters.contentSniffingPolicy = ContentSniffingPolicy::DoNotSniffContent;
58     parameters.contentEncodingSniffingPolicy = ContentEncodingSniffingPolicy::Sniff;
59     parameters.request = m_originalRequest;
60     m_networkLoad = std::make_unique<NetworkLoad>(*this, WTFMove(parameters), *SessionTracker::networkSession(PAL::SessionID::defaultSessionID()));
61 }
62
63 SpeculativeLoad::~SpeculativeLoad()
64 {
65     ASSERT(!m_networkLoad);
66 }
67
68 void SpeculativeLoad::willSendRedirectedRequest(ResourceRequest&& request, ResourceRequest&& redirectRequest, ResourceResponse&& redirectResponse)
69 {
70     LOG(NetworkCacheSpeculativePreloading, "Speculative redirect %s -> %s", request.url().string().utf8().data(), redirectRequest.url().string().utf8().data());
71
72     m_cacheEntry = m_cache->storeRedirect(request, redirectResponse, redirectRequest);
73     // Create a synthetic cache entry if we can't store.
74     if (!m_cacheEntry)
75         m_cacheEntry = m_cache->makeRedirectEntry(request, redirectResponse, redirectRequest);
76
77     // Don't follow the redirect. The redirect target will be registered for speculative load when it is loaded.
78     didComplete();
79 }
80
81 auto SpeculativeLoad::didReceiveResponse(ResourceResponse&& receivedResponse) -> ShouldContinueDidReceiveResponse
82 {
83     m_response = receivedResponse;
84
85     if (m_response.isMultipart())
86         m_bufferedDataForCache = nullptr;
87
88     bool validationSucceeded = m_response.httpStatusCode() == 304; // 304 Not Modified
89     if (validationSucceeded && m_cacheEntry)
90         m_cacheEntry = m_cache->update(m_originalRequest, m_frameID, *m_cacheEntry, m_response);
91     else
92         m_cacheEntry = nullptr;
93
94     return ShouldContinueDidReceiveResponse::Yes;
95 }
96
97 void SpeculativeLoad::didReceiveBuffer(Ref<SharedBuffer>&& buffer, int reportedEncodedDataLength)
98 {
99     ASSERT(!m_cacheEntry);
100
101     if (m_bufferedDataForCache) {
102         // Prevent memory growth in case of streaming data.
103         const size_t maximumCacheBufferSize = 10 * 1024 * 1024;
104         if (m_bufferedDataForCache->size() + buffer->size() <= maximumCacheBufferSize)
105             m_bufferedDataForCache->append(buffer.get());
106         else
107             m_bufferedDataForCache = nullptr;
108     }
109 }
110
111 void SpeculativeLoad::didFinishLoading(const WebCore::NetworkLoadMetrics&)
112 {
113     if (m_didComplete)
114         return;
115     if (!m_cacheEntry && m_bufferedDataForCache) {
116         m_cacheEntry = m_cache->store(m_originalRequest, m_response, m_bufferedDataForCache.copyRef(), [](auto& mappedBody) { });
117         // Create a synthetic cache entry if we can't store.
118         if (!m_cacheEntry && isStatusCodeCacheableByDefault(m_response.httpStatusCode()))
119             m_cacheEntry = m_cache->makeEntry(m_originalRequest, m_response, WTFMove(m_bufferedDataForCache));
120     }
121
122     didComplete();
123 }
124
125 #if USE(PROTECTION_SPACE_AUTH_CALLBACK)
126 void SpeculativeLoad::canAuthenticateAgainstProtectionSpaceAsync(const WebCore::ProtectionSpace&)
127 {
128     m_networkLoad->continueCanAuthenticateAgainstProtectionSpace(false);
129 }
130 #endif
131
132 void SpeculativeLoad::didFailLoading(const ResourceError&)
133 {
134     if (m_didComplete)
135         return;
136     m_cacheEntry = nullptr;
137
138     didComplete();
139 }
140
141 void SpeculativeLoad::didComplete()
142 {
143     RELEASE_ASSERT(RunLoop::isMain());
144
145     if (m_didComplete)
146         return;
147     m_didComplete = true;
148     m_networkLoad = nullptr;
149
150     // Make sure speculatively revalidated resources do not get validated by the NetworkResourceLoader again.
151     if (m_cacheEntry)
152         m_cacheEntry->setNeedsValidation(false);
153
154     m_completionHandler(WTFMove(m_cacheEntry));
155 }
156
157 } // namespace NetworkCache
158 } // namespace WebKit
159
160 #endif // ENABLE(NETWORK_CACHE_SPECULATIVE_REVALIDATION)