Source/WebCore/ChangeLog

 12019-08-12 Youenn Fablet <youenn@apple.com>
 2
 3 Blob registries should be keyed by session IDs
 4 https://bugs.webkit.org/show_bug.cgi?id=200567
 5 <rdar://problem/54120212>
 6
 7 Reviewed by NOBODY (OOPS!).
 8
 9 Pass session IDs to all BlobRegistry methods in particular ThreadableLoaderRegistry.
 10 The only exception is blobSize which should be dealt with a follow-up patch.
 11 blobSize blob registry is retrieved from the connection -> sessionID map in Network Process.
 12 Covered by existing tests.
 13
 14 * Modules/fetch/FetchLoader.cpp:
 15 (WebCore::FetchLoader::~FetchLoader):
 16 (WebCore::FetchLoader::startLoadingBlobURL):
 17 * Modules/fetch/FetchLoader.h:
 18 * fileapi/FileReaderLoader.cpp:
 19 (WebCore::FileReaderLoader::~FileReaderLoader):
 20 (WebCore::FileReaderLoader::start):
 21 * fileapi/FileReaderLoader.h:
 22 * fileapi/ThreadableBlobRegistry.cpp:
 23 (WebCore::ThreadableBlobRegistry::registerFileBlobURL):
 24 (WebCore::ThreadableBlobRegistry::registerBlobURL):
 25 (WebCore::ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked):
 26 * fileapi/ThreadableBlobRegistry.h:
 27 * html/PublicURLManager.cpp:
 28 * loader/PolicyChecker.cpp:
 29 (WebCore::PolicyChecker::extendBlobURLLifetimeIfNecessary const):
 30 * platform/network/BlobRegistry.h:
 31 * platform/network/BlobRegistryImpl.cpp:
 32 (WebCore::createBlobResourceHandle):
 33 (WebCore::loadBlobResourceSynchronously):
 34 (WebCore::BlobRegistryImpl::filesInBlob const):
 35 * platform/network/BlobRegistryImpl.h:
 36 * platform/network/FormData.cpp:
 37 (WebCore::appendBlobResolved):
 38 (WebCore::FormData::resolveBlobReferences):
 39 * platform/network/FormData.h:
 40 * platform/network/cf/FormDataStreamCFNet.cpp:
 41 (WebCore::createHTTPBodyCFReadStream):
 42 * platform/network/soup/ResourceRequest.h:
 43 * platform/network/soup/ResourceRequestSoup.cpp:
 44 (WebCore::ResourceRequest::updateSoupMessageBody const):
 45 (WebCore::ResourceRequest::updateSoupMessage const):
 46
1472019-08-12 Youenn Fablet <youenn@apple.com>
248
349 Remove IDBValue::m_sessionID

Source/WebKit/ChangeLog

 12019-08-12 Youenn Fablet <youenn@apple.com>
 2
 3 Blob registries should be keyed by session IDs
 4 https://bugs.webkit.org/show_bug.cgi?id=200567
 5 <rdar://problem/54120212>
 6
 7 Reviewed by NOBODY (OOPS!).
 8
 9 Move blob registry to NetworkSession so that it is partitioned by session ID.
 10 In case session ID is not given through IPC, use the connection as key to get the network session.
 11 This is used for blobSize.
 12
 13 * NetworkProcess/Downloads/DownloadManager.cpp:
 14 (WebKit::DownloadManager::startDownload):
 15 * NetworkProcess/Downloads/DownloadManager.h:
 16 * NetworkProcess/FileAPI/NetworkBlobRegistry.cpp:
 17 * NetworkProcess/FileAPI/NetworkBlobRegistry.h: Removed.
 18 * NetworkProcess/NetworkConnectionToWebProcess.cpp:
 19 (WebKit::NetworkConnectionToWebProcess::didClose):
 20 (WebKit::NetworkConnectionToWebProcess::resolveBlobReferences):
 21 (WebKit::NetworkConnectionToWebProcess::registerFileBlobURL):
 22 (WebKit::NetworkConnectionToWebProcess::registerBlobURL):
 23 (WebKit::NetworkConnectionToWebProcess::registerBlobURLFromURL):
 24 (WebKit::NetworkConnectionToWebProcess::registerBlobURLOptionallyFileBacked):
 25 (WebKit::NetworkConnectionToWebProcess::registerBlobURLForSlice):
 26 (WebKit::NetworkConnectionToWebProcess::unregisterBlobURL):
 27 (WebKit::NetworkConnectionToWebProcess::blobSize):
 28 (WebKit::NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles):
 29 (WebKit::NetworkConnectionToWebProcess::filesInBlob):
 30 * NetworkProcess/NetworkConnectionToWebProcess.h:
 31 * NetworkProcess/NetworkConnectionToWebProcess.messages.in:
 32 * NetworkProcess/NetworkProcess.cpp:
 33 (WebKit::NetworkProcess::blobRegistry):
 34 * NetworkProcess/NetworkProcess.h:
 35 * NetworkProcess/NetworkProcessPlatformStrategies.cpp:
 36 (WebKit::NetworkProcessPlatformStrategies::createBlobRegistry):
 37 * NetworkProcess/NetworkResourceLoader.cpp:
 38 (WebKit::NetworkResourceLoader::startNetworkLoad):
 39 * NetworkProcess/NetworkSession.h:
 40 (WebKit::NetworkSession::blobRegistry):
 41 * NetworkProcess/soup/NetworkDataTaskSoup.cpp:
 42 (WebKit::NetworkDataTaskSoup::createRequest):
 43 * NetworkProcess/soup/NetworkSessionSoup.cpp:
 44 (WebKit::NetworkSessionSoup::createWebSocketTask):
 45 * Sources.txt:
 46 * WebKit.xcodeproj/project.pbxproj:
 47 * WebProcess/FileAPI/BlobRegistryProxy.cpp:
 48 (WebKit::BlobRegistryProxy::registerFileBlobURL):
 49 (WebKit::BlobRegistryProxy::registerBlobURL):
 50 (WebKit::BlobRegistryProxy::registerBlobURLOptionallyFileBacked):
 51 (WebKit::BlobRegistryProxy::unregisterBlobURL):
 52 (WebKit::BlobRegistryProxy::registerBlobURLForSlice):
 53 (WebKit::BlobRegistryProxy::writeBlobsToTemporaryFiles):
 54 * WebProcess/FileAPI/BlobRegistryProxy.h:
 55 * WebProcess/Network/NetworkProcessConnection.cpp:
 56 (WebKit::NetworkProcessConnection::writeBlobsToTemporaryFiles):
 57 * WebProcess/Network/NetworkProcessConnection.h:
 58
1592019-08-12 Youenn Fablet <youenn@apple.com>
260
361 Remove IDB-specific quota

Source/WebKitLegacy/mac/ChangeLog

 12019-08-12 Youenn Fablet <youenn@apple.com>
 2
 3 Blob registries should be keyed by session IDs
 4 https://bugs.webkit.org/show_bug.cgi?id=200567
 5
 6 Reviewed by NOBODY (OOPS!).
 7
 8 * WebCoreSupport/WebPlatformStrategies.mm:
 9 (WebPlatformStrategies::createBlobRegistry):
 10 Ignore sessionID parameter for WK1.
 11
1122019-08-12 Youenn Fablet <youenn@apple.com>
213
314 Remove IDB-specific quota

Source/WebKitLegacy/win/ChangeLog

 12019-08-12 Youenn Fablet <youenn@apple.com>
 2
 3 Blob registries should be keyed by session IDs
 4 https://bugs.webkit.org/show_bug.cgi?id=200567
 5 <rdar://problem/54120212>
 6
 7 Reviewed by NOBODY (OOPS!).
 8
 9 * WebCoreSupport/WebPlatformStrategies.cpp:
 10 (WebPlatformStrategies::createBlobRegistry):
 11
1122019-08-12 Youenn Fablet <youenn@apple.com>
213
314 Remove IDB-specific quota

Source/WebCore/Modules/fetch/FetchLoader.cpp

@@namespace WebCore {
4848FetchLoader::~FetchLoader()
4949{
5050 if (!m_urlForReading.isEmpty())
51  ThreadableBlobRegistry::unregisterBlobURL(m_urlForReading);
 51 ThreadableBlobRegistry::unregisterBlobURL(*m_sessionID, m_urlForReading);
5252}
5353
5454void FetchLoader::start(ScriptExecutionContext& context, const Blob& blob)

@@void FetchLoader::startLoadingBlobURL(ScriptExecutionContext& context, const URL
6464 return;
6565 }
6666
67  ThreadableBlobRegistry::registerBlobURL(context.securityOrigin(), m_urlForReading, blobURL);
 67 m_sessionID = context.sessionID();
 68 ThreadableBlobRegistry::registerBlobURL(*m_sessionID, context.securityOrigin(), m_urlForReading, blobURL);
6869
6970 ResourceRequest request(m_urlForReading);
7071 request.setInitiatorIdentifier(context.resourceRequestIdentifier());

Source/WebCore/Modules/fetch/FetchLoader.h

@@private:
6767 FetchBodyConsumer* m_consumer;
6868 bool m_isStarted { false };
6969 URL m_urlForReading;
 70 Optional<PAL::SessionID> m_sessionID;
7071};
7172
7273} // namespace WebCore

Source/WebCore/bindings/js/SerializedScriptValue.cpp

@@Vector<String> SerializedScriptValue::blobURLsIsolatedCopy() const
35693569 return result;
35703570}
35713571
3572 void SerializedScriptValue::writeBlobsToDiskForIndexedDB(PAL::SessionID, CompletionHandler<void(IDBValue&&)>&& completionHandler)
 3572void SerializedScriptValue::writeBlobsToDiskForIndexedDB(PAL::SessionID sessionID, CompletionHandler<void(IDBValue&&)>&& completionHandler)
35733573{
35743574 ASSERT(isMainThread());
35753575 ASSERT(hasBlobURLs());
35763576
3577  // FIXME: Get the right blob registry from the given sessionID.
3578  blobRegistry().writeBlobsToTemporaryFiles(m_blobURLs, [completionHandler = WTFMove(completionHandler), this, protectedThis = makeRef(*this)] (auto&& blobFilePaths) mutable {
 3577 blobRegistry().writeBlobsToTemporaryFiles(sessionID, m_blobURLs, [completionHandler = WTFMove(completionHandler), this, protectedThis = makeRef(*this)] (auto&& blobFilePaths) mutable {
35793578 ASSERT(isMainThread());
35803579
35813580 if (blobFilePaths.isEmpty()) {

@@void SerializedScriptValue::writeBlobsToDiskForIndexedDB(PAL::SessionID, Complet
35863585 }
35873586
35883587 ASSERT(m_blobURLs.size() == blobFilePaths.size());
3589 
 3588
35903589 completionHandler({ *this, m_blobURLs, blobFilePaths });
35913590 });
35923591}

Source/WebCore/fileapi/Blob.cpp

@@public:
5858void BlobURLRegistry::registerURL(ScriptExecutionContext& context, const URL& publicURL, URLRegistrable& blob)
5959{
6060 ASSERT(&blob.registry() == this);
61  ThreadableBlobRegistry::registerBlobURL(context.securityOrigin(), publicURL, static_cast<Blob&>(blob).url());
 61 ThreadableBlobRegistry::registerBlobURL(context.sessionID(), context.securityOrigin(), publicURL, static_cast<Blob&>(blob).url());
6262}
6363
64 void BlobURLRegistry::unregisterURL(ScriptExecutionContext&, const URL& url)
 64void BlobURLRegistry::unregisterURL(ScriptExecutionContext& context, const URL& url)
6565{
66  ThreadableBlobRegistry::unregisterBlobURL(url);
 66 ThreadableBlobRegistry::unregisterBlobURL(context.sessionID(), url);
6767}
6868
6969URLRegistry& BlobURLRegistry::registry()

@@Blob::Blob(PAL::SessionID sessionID)
8282 , m_size(0)
8383{
8484 m_internalURL = BlobURL::createInternalURL();
85  ThreadableBlobRegistry::registerBlobURL(m_internalURL, { }, { });
 85 ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, { }, { });
8686}
8787
8888Blob::Blob(PAL::SessionID sessionID, Vector<BlobPartVariant>&& blobPartVariants, const BlobPropertyBag& propertyBag)

@@Blob::Blob(PAL::SessionID sessionID, Vector<BlobPartVariant>&& blobPartVariants,
100100 );
101101 }
102102
103  ThreadableBlobRegistry::registerBlobURL(m_internalURL, builder.finalize(), m_type);
 103 ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, builder.finalize(), m_type);
104104}
105105
106106Blob::Blob(PAL::SessionID sessionID, const SharedBuffer& buffer, const String& contentType)

@@Blob::Blob(PAL::SessionID sessionID, const SharedBuffer& buffer, const String& c
114114 Vector<BlobPart> blobParts;
115115 blobParts.append(BlobPart(WTFMove(data)));
116116 m_internalURL = BlobURL::createInternalURL();
117  ThreadableBlobRegistry::registerBlobURL(m_internalURL, WTFMove(blobParts), contentType);
 117 ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, WTFMove(blobParts), contentType);
118118}
119119
120120Blob::Blob(PAL::SessionID sessionID, Vector<uint8_t>&& data, const String& contentType)

@@Blob::Blob(PAL::SessionID sessionID, Vector<uint8_t>&& data, const String& conte
125125 Vector<BlobPart> blobParts;
126126 blobParts.append(BlobPart(WTFMove(data)));
127127 m_internalURL = BlobURL::createInternalURL();
128  ThreadableBlobRegistry::registerBlobURL(m_internalURL, WTFMove(blobParts), contentType);
 128 ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, WTFMove(blobParts), contentType);
129129}
130130
131131Blob::Blob(ReferencingExistingBlobConstructor, const Blob& blob)

@@Blob::Blob(ReferencingExistingBlobConstructor, const Blob& blob)
134134 , m_type(blob.type())
135135 , m_size(blob.size())
136136{
137  ThreadableBlobRegistry::registerBlobURL(m_internalURL, { BlobPart(blob.url()) } , m_type);
 137 ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, { BlobPart(blob.url()) } , m_type);
138138}
139139
140140Blob::Blob(DeserializationContructor, PAL::SessionID sessionID, const URL& srcURL, const String& type, long long size, const String& fileBackedPath)

@@Blob::Blob(DeserializationContructor, PAL::SessionID sessionID, const URL& srcUR
144144{
145145 m_internalURL = BlobURL::createInternalURL();
146146 if (fileBackedPath.isEmpty())
147  ThreadableBlobRegistry::registerBlobURL(nullptr, m_internalURL, srcURL);
 147 ThreadableBlobRegistry::registerBlobURL(m_sessionID, nullptr, m_internalURL, srcURL);
148148 else
149  ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked(m_internalURL, srcURL, fileBackedPath, m_type);
 149 ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked(m_sessionID, m_internalURL, srcURL, fileBackedPath, m_type);
150150}
151151
152152Blob::Blob(PAL::SessionID sessionID, const URL& srcURL, long long start, long long end, const String& type)

@@Blob::Blob(PAL::SessionID sessionID, const URL& srcURL, long long start, long lo
155155 , m_size(-1) // size is not necessarily equal to end - start.
156156{
157157 m_internalURL = BlobURL::createInternalURL();
158  ThreadableBlobRegistry::registerBlobURLForSlice(m_internalURL, srcURL, start, end);
 158 ThreadableBlobRegistry::registerBlobURLForSlice(m_sessionID, m_internalURL, srcURL, start, end);
159159}
160160
161161Blob::~Blob()
162162{
163  ThreadableBlobRegistry::unregisterBlobURL(m_internalURL);
 163 ThreadableBlobRegistry::unregisterBlobURL(m_sessionID, m_internalURL);
164164}
165165
166166unsigned long long Blob::size() const

Source/WebCore/fileapi/File.cpp

@@File::File(PAL::SessionID sessionID, const String& path)
5353 m_internalURL = BlobURL::createInternalURL();
5454 m_size = -1;
5555 computeNameAndContentType(m_path, String(), m_name, m_type);
56  ThreadableBlobRegistry::registerFileBlobURL(m_internalURL, path, m_type);
 56 ThreadableBlobRegistry::registerFileBlobURL(sessionID, m_internalURL, path, m_type);
5757}
5858
5959File::File(PAL::SessionID sessionID, const String& path, const String& nameOverride)

@@File::File(PAL::SessionID sessionID, const String& path, const String& nameOverr
6363 m_internalURL = BlobURL::createInternalURL();
6464 m_size = -1;
6565 computeNameAndContentType(m_path, nameOverride, m_name, m_type);
66  ThreadableBlobRegistry::registerFileBlobURL(m_internalURL, path, m_type);
 66 ThreadableBlobRegistry::registerFileBlobURL(sessionID, m_internalURL, path, m_type);
6767}
6868
6969File::File(DeserializationContructor, PAL::SessionID sessionID, const String& path, const URL& url, const String& type, const String& name, const Optional<int64_t>& lastModified)

Source/WebCore/fileapi/FileReaderLoader.cpp

@@FileReaderLoader::~FileReaderLoader()
6868{
6969 terminate();
7070 if (!m_urlForReading.isEmpty())
71  ThreadableBlobRegistry::unregisterBlobURL(m_urlForReading);
 71 ThreadableBlobRegistry::unregisterBlobURL(*m_sessionID, m_urlForReading);
7272}
7373
7474void FileReaderLoader::start(ScriptExecutionContext* scriptExecutionContext, Blob& blob)

@@void FileReaderLoader::start(ScriptExecutionContext* scriptExecutionContext, Blo
8181 failed(FileError::SECURITY_ERR);
8282 return;
8383 }
84  ThreadableBlobRegistry::registerBlobURL(scriptExecutionContext->securityOrigin(), m_urlForReading, blob.url());
 84 m_sessionID = scriptExecutionContext->sessionID();
 85 ThreadableBlobRegistry::registerBlobURL(*m_sessionID, scriptExecutionContext->securityOrigin(), m_urlForReading, blob.url());
8586
8687 // Construct and load the request.
8788 ResourceRequest request(m_urlForReading);

Source/WebCore/fileapi/FileReaderLoader.h

3535#include <wtf/URL.h>
3636#include "TextEncoding.h"
3737#include "ThreadableLoaderClient.h"
 38#include <pal/SessionID.h>
3839#include <wtf/Forward.h>
3940#include <wtf/text/WTFString.h>
4041

@@private:
102103 String m_dataType;
103104
104105 URL m_urlForReading;
 106 Optional<PAL::SessionID> m_sessionID;
105107 RefPtr<ThreadableLoader> m_loader;
106108
107109 RefPtr<JSC::ArrayBuffer> m_rawData;

Source/WebCore/fileapi/ThreadableBlobRegistry.cpp

@@static ThreadSpecific<BlobUrlOriginMap>& originMap()
6464 return *map;
6565}
6666
67 static void postToMainThread(CrossThreadTask&& task)
 67void ThreadableBlobRegistry::registerFileBlobURL(PAL::SessionID sessionID, const URL& url, const String& path, const String& contentType)
6868{
69  static std::once_flag onceFlag;
70  static CrossThreadQueue<CrossThreadTask>* queue;
71  std::call_once(onceFlag, [] {
72  queue = new CrossThreadQueue<CrossThreadTask>;
73  });
74 
75  queue->append(WTFMove(task));
 69 if (isMainThread()) {
 70 blobRegistry().registerFileBlobURL(sessionID, url, BlobDataFileReference::create(path), contentType);
 71 return;
 72 }
7673
77  callOnMainThread([] {
78  auto task = queue->tryGetMessage();
79  ASSERT(task);
80  task->performTask();
 74 callOnMainThread([sessionID, url = url.isolatedCopy(), path = path.isolatedCopy(), contentType = contentType.isolatedCopy()] {
 75 blobRegistry().registerFileBlobURL(sessionID, url, BlobDataFileReference::create(path), contentType);
8176 });
8277}
8378
84 void ThreadableBlobRegistry::registerFileBlobURL(const URL& url, const String& path, const String& contentType)
85 {
86  if (isMainThread())
87  blobRegistry().registerFileBlobURL(url, BlobDataFileReference::create(path), contentType);
88  else {
89  callOnMainThread([url = url.isolatedCopy(), path = path.isolatedCopy(), contentType = contentType.isolatedCopy()] {
90  blobRegistry().registerFileBlobURL(url, BlobDataFileReference::create(path), contentType);
91  });
92  }
93 }
94 
95 void ThreadableBlobRegistry::registerBlobURL(const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
 79void ThreadableBlobRegistry::registerBlobURL(PAL::SessionID sessionID, const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
9680{
97  if (isMainThread())
98  blobRegistry().registerBlobURL(url, WTFMove(blobParts), contentType);
99  else {
100  for (auto& part : blobParts)
101  part.detachFromCurrentThread();
102  callOnMainThread([url = url.isolatedCopy(), blobParts = WTFMove(blobParts), contentType = contentType.isolatedCopy()]() mutable {
103  blobRegistry().registerBlobURL(url, WTFMove(blobParts), contentType);
104  });
 81 if (isMainThread()) {
 82 blobRegistry().registerBlobURL(sessionID, url, WTFMove(blobParts), contentType);
 83 return;
10584 }
 85 for (auto& part : blobParts)
 86 part.detachFromCurrentThread();
 87 callOnMainThread([sessionID, url = url.isolatedCopy(), blobParts = WTFMove(blobParts), contentType = contentType.isolatedCopy()]() mutable {
 88 blobRegistry().registerBlobURL(sessionID, url, WTFMove(blobParts), contentType);
 89 });
10690}
10791
108 void ThreadableBlobRegistry::registerBlobURL(SecurityOrigin* origin, const URL& url, const URL& srcURL)
 92void ThreadableBlobRegistry::registerBlobURL(PAL::SessionID sessionID, SecurityOrigin* origin, const URL& url, const URL& srcURL)
10993{
11094 // If the blob URL contains null origin, as in the context with unique security origin or file URL, save the mapping between url and origin so that the origin can be retrived when doing security origin check.
11195 if (origin && BlobURL::getOrigin(url) == "null")
11296 originMap()->add(url.string(), origin);
11397
114  if (isMainThread())
115  blobRegistry().registerBlobURL(url, srcURL);
116  else {
117  callOnMainThread([url = url.isolatedCopy(), srcURL = srcURL.isolatedCopy()] {
118  blobRegistry().registerBlobURL(url, srcURL);
119  });
 98 if (isMainThread()) {
 99 blobRegistry().registerBlobURL(sessionID, url, srcURL);
 100 return;
120101 }
 102
 103 callOnMainThread([sessionID, url = url.isolatedCopy(), srcURL = srcURL.isolatedCopy()] {
 104 blobRegistry().registerBlobURL(sessionID, url, srcURL);
 105 });
121106}
122107
123 void ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked(const URL& url, const URL& srcURL, const String& fileBackedPath, const String& contentType)
 108void ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked(PAL::SessionID sessionID, const URL& url, const URL& srcURL, const String& fileBackedPath, const String& contentType)
124109{
125  if (isMainThread())
126  blobRegistry().registerBlobURLOptionallyFileBacked(url, srcURL, BlobDataFileReference::create(fileBackedPath), contentType);
127  else
128  postToMainThread(createCrossThreadTask(ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked, url, srcURL, fileBackedPath, contentType));
 110 if (isMainThread()) {
 111 blobRegistry().registerBlobURLOptionallyFileBacked(sessionID, url, srcURL, BlobDataFileReference::create(fileBackedPath), contentType);
 112 return;
 113 }
 114 callOnMainThread([sessionID, url = url.isolatedCopy(), srcURL = srcURL.isolatedCopy(), fileBackedPath = fileBackedPath.isolatedCopy(), contentType = contentType.isolatedCopy()] {
 115 blobRegistry().registerBlobURLOptionallyFileBacked(sessionID, url, srcURL, BlobDataFileReference::create(fileBackedPath), contentType);
 116 });
129117}
130118
131 void ThreadableBlobRegistry::registerBlobURLForSlice(const URL& newURL, const URL& srcURL, long long start, long long end)
 119void ThreadableBlobRegistry::registerBlobURLForSlice(PAL::SessionID sessionID, const URL& newURL, const URL& srcURL, long long start, long long end)
132120{
133  if (isMainThread())
134  blobRegistry().registerBlobURLForSlice(newURL, srcURL, start, end);
135  else {
136  callOnMainThread([newURL = newURL.isolatedCopy(), srcURL = srcURL.isolatedCopy(), start, end] {
137  blobRegistry().registerBlobURLForSlice(newURL, srcURL, start, end);
138  });
 121 if (isMainThread()) {
 122 blobRegistry().registerBlobURLForSlice(sessionID, newURL, srcURL, start, end);
 123 return;
139124 }
 125
 126 callOnMainThread([sessionID, newURL = newURL.isolatedCopy(), srcURL = srcURL.isolatedCopy(), start, end] {
 127 blobRegistry().registerBlobURLForSlice(sessionID, newURL, srcURL, start, end);
 128 });
140129}
141130
142131unsigned long long ThreadableBlobRegistry::blobSize(const URL& url)
143132{
144  unsigned long long resultSize;
145133 if (isMainThread())
 134 return blobRegistry().blobSize(url);
 135
 136 unsigned long long resultSize;
 137 BinarySemaphore semaphore;
 138 callOnMainThread([url = url.isolatedCopy(), &semaphore, &resultSize] {
146139 resultSize = blobRegistry().blobSize(url);
147  else {
148  BinarySemaphore semaphore;
149  callOnMainThread([url = url.isolatedCopy(), &semaphore, &resultSize] {
150  resultSize = blobRegistry().blobSize(url);
151  semaphore.signal();
152  });
153  semaphore.wait();
154  }
 140 semaphore.signal();
 141 });
 142 semaphore.wait();
155143 return resultSize;
156144}
157145
158 void ThreadableBlobRegistry::unregisterBlobURL(const URL& url)
 146void ThreadableBlobRegistry::unregisterBlobURL(PAL::SessionID sessionID, const URL& url)
159147{
160148 if (BlobURL::getOrigin(url) == "null")
161149 originMap()->remove(url.string());
162150
163  if (isMainThread())
164  blobRegistry().unregisterBlobURL(url);
165  else {
166  callOnMainThread([url = url.isolatedCopy()] {
167  blobRegistry().unregisterBlobURL(url);
168  });
 151 if (isMainThread()) {
 152 blobRegistry().unregisterBlobURL(sessionID, url);
 153 return;
169154 }
 155 callOnMainThread([sessionID, url = url.isolatedCopy()] {
 156 blobRegistry().unregisterBlobURL(sessionID, url);
 157 });
170158}
171159
172160RefPtr<SecurityOrigin> ThreadableBlobRegistry::getCachedOrigin(const URL& url)

Source/WebCore/fileapi/ThreadableBlobRegistry.h

@@class SecurityOrigin;
4040
4141class ThreadableBlobRegistry {
4242public:
43  static void registerFileBlobURL(const URL&, const String& path, const String& contentType);
44  static void registerBlobURL(const URL&, Vector<BlobPart>&& blobParts, const String& contentType);
45  static void registerBlobURL(SecurityOrigin*, const URL&, const URL& srcURL);
46  static void registerBlobURLOptionallyFileBacked(const URL&, const URL& srcURL, const String& fileBackedPath, const String& contentType);
47  static void registerBlobURLForSlice(const URL& newURL, const URL& srcURL, long long start, long long end);
48  static void unregisterBlobURL(const URL&);
 43 static void registerFileBlobURL(PAL::SessionID, const URL&, const String& path, const String& contentType);
 44 static void registerBlobURL(PAL::SessionID, const URL&, Vector<BlobPart>&& blobParts, const String& contentType);
 45 static void registerBlobURL(PAL::SessionID, SecurityOrigin*, const URL&, const URL& srcURL);
 46 static void registerBlobURLOptionallyFileBacked(PAL::SessionID, const URL&, const URL& srcURL, const String& fileBackedPath, const String& contentType);
 47 static void registerBlobURLForSlice(PAL::SessionID, const URL& newURL, const URL& srcURL, long long start, long long end);
 48 static void unregisterBlobURL(PAL::SessionID, const URL&);
4949
5050 static unsigned long long blobSize(const URL&);
5151

Source/WebCore/html/PublicURLManager.cpp

2626
2727#include "config.h"
2828#include "PublicURLManager.h"
29 #include <wtf/URL.h>
 29
3030#include "URLRegistry.h"
 31#include <wtf/URL.h>
3132#include <wtf/text/StringHash.h>
3233
3334namespace WebCore {

Source/WebCore/loader/PolicyChecker.cpp

@@CompletionHandlerCallingScope PolicyChecker::extendBlobURLLifetimeIfNecessary(Re
106106
107107 // Create a new temporary blobURL in case this one gets revoked during the asynchronous navigation policy decision.
108108 URL temporaryBlobURL = BlobURL::createPublicURL(&m_frame.document()->securityOrigin());
109  blobRegistry().registerBlobURL(temporaryBlobURL, request.url());
 109 auto sessionID = m_frame.document()->sessionID();
 110 blobRegistry().registerBlobURL(sessionID, temporaryBlobURL, request.url());
110111 request.setURL(temporaryBlobURL);
111  return CompletionHandler<void()>([temporaryBlobURL = WTFMove(temporaryBlobURL)] {
112  blobRegistry().unregisterBlobURL(temporaryBlobURL);
 112 return CompletionHandler<void()>([sessionID, temporaryBlobURL = WTFMove(temporaryBlobURL)] {
 113 blobRegistry().unregisterBlobURL(sessionID, temporaryBlobURL);
113114 });
114115}
115116

Source/WebCore/platform/network/BlobRegistry.h

3131
3232#pragma once
3333
 34#include <pal/SessionID.h>
3435#include <wtf/Forward.h>
3536
3637namespace WebCore {

@@namespace WebCore {
3839class BlobDataFileReference;
3940class BlobPart;
4041class BlobRegistry;
 42class BlobRegistryImpl;
4143
4244WEBCORE_EXPORT BlobRegistry& blobRegistry();
4345

@@class WEBCORE_EXPORT BlobRegistry {
4648public:
4749
4850 // Registers a blob URL referring to the specified file.
49  virtual void registerFileBlobURL(const URL&, Ref<BlobDataFileReference>&&, const String& contentType) = 0;
 51 virtual void registerFileBlobURL(PAL::SessionID, const URL&, Ref<BlobDataFileReference>&&, const String& contentType) = 0;
5052
5153 // Registers a blob URL referring to the specified blob data.
52  virtual void registerBlobURL(const URL&, Vector<BlobPart>&&, const String& contentType) = 0;
 54 virtual void registerBlobURL(PAL::SessionID, const URL&, Vector<BlobPart>&&, const String& contentType) = 0;
5355
5456 // Registers a new blob URL referring to the blob data identified by the specified srcURL.
55  virtual void registerBlobURL(const URL&, const URL& srcURL) = 0;
 57 virtual void registerBlobURL(PAL::SessionID, const URL&, const URL& srcURL) = 0;
5658
5759 // Registers a new blob URL referring to the blob data identified by the specified srcURL or, if none found, referring to the file found at the given path.
58  virtual void registerBlobURLOptionallyFileBacked(const URL&, const URL& srcURL, RefPtr<BlobDataFileReference>&&, const String& contentType) = 0;
 60 virtual void registerBlobURLOptionallyFileBacked(PAL::SessionID, const URL&, const URL& srcURL, RefPtr<BlobDataFileReference>&&, const String& contentType) = 0;
5961
6062 // Negative start and end values select from the end.
61  virtual void registerBlobURLForSlice(const URL&, const URL& srcURL, long long start, long long end) = 0;
 63 virtual void registerBlobURLForSlice(PAL::SessionID, const URL&, const URL& srcURL, long long start, long long end) = 0;
6264
63  virtual void unregisterBlobURL(const URL&) = 0;
 65 virtual void unregisterBlobURL(PAL::SessionID, const URL&) = 0;
6466
6567 virtual unsigned long long blobSize(const URL&) = 0;
6668
67  virtual void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&) = 0;
 69 virtual void writeBlobsToTemporaryFiles(PAL::SessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&) = 0;
6870
69  virtual bool isBlobRegistryImpl() const { return false; }
 71 virtual BlobRegistryImpl* blobRegistryImpl() { return nullptr; }
7072
7173protected:
7274 virtual ~BlobRegistry();

Source/WebCore/platform/network/BlobRegistryImpl.cpp

@@BlobRegistryImpl::~BlobRegistryImpl() = default;
5454
5555static Ref<ResourceHandle> createBlobResourceHandle(const ResourceRequest& request, ResourceHandleClient* client)
5656{
57  return static_cast<BlobRegistryImpl&>(blobRegistry()).createResourceHandle(request, client);
 57 return blobRegistry().blobRegistryImpl()->createResourceHandle(request, client);
5858}
5959
6060static void loadBlobResourceSynchronously(NetworkingContext*, const ResourceRequest& request, StoredCredentialsPolicy, ResourceError& error, ResourceResponse& response, Vector<char>& data)
6161{
62  BlobData* blobData = static_cast<BlobRegistryImpl&>(blobRegistry()).getBlobDataFromURL(request.url());
 62 auto* blobData = blobRegistry().blobRegistryImpl()->getBlobDataFromURL(request.url());
6363 BlobResourceHandle::loadResourceSynchronously(blobData, request, error, response, data);
6464}
6565

@@void BlobRegistryImpl::writeBlobToFilePath(const URL& blobURL, const String& pat
343343 });
344344}
345345
 346Vector<RefPtr<BlobDataFileReference>> BlobRegistryImpl::filesInBlob(const URL& url) const
 347{
 348 auto* blobData = getBlobDataFromURL(url);
 349 if (!blobData)
 350 return { };
 351
 352 Vector<RefPtr<BlobDataFileReference>> result;
 353 for (const BlobDataItem& item : blobData->items()) {
 354 if (item.type() == BlobDataItem::Type::File)
 355 result.append(item.file());
 356 }
 357
 358 return result;
 359}
 360
346361} // namespace WebCore

Source/WebCore/platform/network/BlobRegistryImpl.h

@@class ResourceRequest;
4646class ThreadSafeDataBuffer;
4747
4848// BlobRegistryImpl is not thread-safe. It should only be called from main thread.
49 class WEBCORE_EXPORT BlobRegistryImpl final : public BlobRegistry {
 49class WEBCORE_EXPORT BlobRegistryImpl {
5050 WTF_MAKE_FAST_ALLOCATED;
5151public:
5252 virtual ~BlobRegistryImpl();

@@public:
5858
5959 void appendStorageItems(BlobData*, const BlobDataItemList&, long long offset, long long length);
6060
61  void registerFileBlobURL(const URL&, Ref<BlobDataFileReference>&&, const String& contentType) override;
62  void registerBlobURL(const URL&, Vector<BlobPart>&&, const String& contentType) override;
63  void registerBlobURL(const URL&, const URL& srcURL) override;
64  void registerBlobURLOptionallyFileBacked(const URL&, const URL& srcURL, RefPtr<BlobDataFileReference>&&, const String& contentType) override;
65  void registerBlobURLForSlice(const URL&, const URL& srcURL, long long start, long long end) override;
66  void unregisterBlobURL(const URL&) override;
67  bool isBlobRegistryImpl() const override { return true; }
 61 void registerFileBlobURL(const URL&, Ref<BlobDataFileReference>&&, const String& contentType);
 62 void registerBlobURL(const URL&, Vector<BlobPart>&&, const String& contentType);
 63 void registerBlobURL(const URL&, const URL& srcURL);
 64 void registerBlobURLOptionallyFileBacked(const URL&, const URL& srcURL, RefPtr<BlobDataFileReference>&&, const String& contentType);
 65 void registerBlobURLForSlice(const URL&, const URL& srcURL, long long start, long long end);
 66 void unregisterBlobURL(const URL&);
6867
69  unsigned long long blobSize(const URL&) override;
 68 unsigned long long blobSize(const URL&);
7069
71  void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&) override;
 70 void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&);
7271
7372 struct BlobForFileWriting {
7473 String blobURL;

@@public:
7675 };
7776
7877 bool populateBlobsForFileWriting(const Vector<String>& blobURLs, Vector<BlobForFileWriting>&);
 78 Vector<RefPtr<BlobDataFileReference>> filesInBlob(const URL&) const;
7979
8080private:
8181 HashMap<String, RefPtr<BlobData>> m_blobs;

Source/WebCore/platform/network/FormData.cpp

@@String FormData::flattenToString() const
286286 return Latin1Encoding().decode(reinterpret_cast<const char*>(bytes.data()), bytes.size());
287287}
288288
289 static void appendBlobResolved(BlobRegistry& blobRegistry, FormData& formData, const URL& url)
 289static void appendBlobResolved(BlobRegistryImpl* blobRegistry, FormData& formData, const URL& url)
290290{
291  if (!blobRegistry.isBlobRegistryImpl()) {
 291 if (!blobRegistry) {
292292 LOG_ERROR("Tried to resolve a blob without a usable registry");
293293 return;
294294 }
295295
296  auto* blobData = static_cast<BlobRegistryImpl&>(blobRegistry).getBlobDataFromURL(url);
 296 auto* blobData = blobRegistry->getBlobDataFromURL(url);
297297 if (!blobData) {
298298 LOG_ERROR("Could not get blob data from a registry");
299299 return;

@@static void appendBlobResolved(BlobRegistry& blobRegistry, FormData& formData, c
310310 }
311311}
312312
313 Ref<FormData> FormData::resolveBlobReferences(BlobRegistry& blobRegistry)
 313Ref<FormData> FormData::resolveBlobReferences(BlobRegistryImpl* blobRegistry)
314314{
315315 // First check if any blobs needs to be resolved, or we can take the fast path.
316316 bool hasBlob = false;

Source/WebCore/platform/network/FormData.h

2929
3030namespace WebCore {
3131
32 class BlobRegistry;
 32class BlobRegistryImpl;
3333class DOMFormData;
3434class File;
3535class SharedBuffer;

@@public:
219219
220220 // Resolve all blob references so we only have file and data.
221221 // If the FormData has no blob references to resolve, this is returned.
222  WEBCORE_EXPORT Ref<FormData> resolveBlobReferences(BlobRegistry&);
 222 WEBCORE_EXPORT Ref<FormData> resolveBlobReferences(BlobRegistryImpl*);
223223
224224 WEBCORE_EXPORT FormDataForUpload prepareForUpload();
225225

Source/WebCore/platform/network/cf/FormDataStreamCFNet.cpp

@@static void formEventCallback(CFReadStreamRef stream, CFStreamEventType type, vo
372372
373373RetainPtr<CFReadStreamRef> createHTTPBodyCFReadStream(FormData& formData)
374374{
375  auto resolvedFormData = formData.resolveBlobReferences(blobRegistry());
 375 auto resolvedFormData = formData.resolveBlobReferences(blobRegistry().blobRegistryImpl());
376376 auto dataForUpload = resolvedFormData->prepareForUpload();
377377
378378 // Precompute the content length so CFNetwork doesn't use chunked mode.

Source/WebCore/platform/network/soup/ResourceRequest.h

3333
3434namespace WebCore {
3535
 36 class BlobRegistryImpl;
 37
3638 class ResourceRequest : public ResourceRequestBase {
3739 public:
3840 ResourceRequest(const String& url)

@@namespace WebCore {
8789
8890 void updateSoupMessageHeaders(SoupMessageHeaders*) const;
8991 void updateFromSoupMessageHeaders(SoupMessageHeaders*);
90  void updateSoupMessage(SoupMessage*) const;
 92 void updateSoupMessage(SoupMessage*, BlobRegistryImpl&) const;
9193 void updateFromSoupMessage(SoupMessage*);
9294 void updateSoupRequest(SoupRequest*) const;
9395 void updateFromSoupRequest(SoupRequest*);

@@namespace WebCore {
111113 Optional<PageIdentifier> m_initiatingPageID;
112114
113115 void updateSoupMessageMembers(SoupMessage*) const;
114  void updateSoupMessageBody(SoupMessage*) const;
 116 void updateSoupMessageBody(SoupMessage*, BlobRegistryImpl&) const;
115117 void doUpdatePlatformRequest() { }
116118 void doUpdateResourceRequest() { }
117119 void doUpdatePlatformHTTPBody() { }

Source/WebCore/platform/network/soup/ResourceRequestSoup.cpp

@@static uint64_t appendEncodedBlobItemToSoupMessageBody(SoupMessage* soupMessage,
6868 return 0;
6969}
7070
71 void ResourceRequest::updateSoupMessageBody(SoupMessage* soupMessage) const
 71void ResourceRequest::updateSoupMessageBody(SoupMessage* soupMessage, BlobRegistryImpl& blobRegistry) const
7272{
7373 auto* formData = httpBody();
7474 if (!formData || formData->isEmpty())

@@void ResourceRequest::updateSoupMessageBody(SoupMessage* soupMessage) const
9292 soup_message_body_append_buffer(soupMessage->request_body, soupBuffer.get());
9393 }
9494 }, [&] (const FormDataElement::EncodedBlobData& blob) {
95  if (auto* blobData = static_cast<BlobRegistryImpl&>(blobRegistry()).getBlobDataFromURL(blob.url)) {
 95 if (auto* blobData = blobRegistry.getBlobDataFromURL(blob.url)) {
9696 for (const auto& item : blobData->items())
9797 bodySize += appendEncodedBlobItemToSoupMessageBody(soupMessage, item);
9898 }

@@void ResourceRequest::updateFromSoupMessageHeaders(SoupMessageHeaders* soupHeade
140140 m_httpHeaderFields.set(String(headerName), String(headerValue));
141141}
142142
143 void ResourceRequest::updateSoupMessage(SoupMessage* soupMessage) const
 143void ResourceRequest::updateSoupMessage(SoupMessage* soupMessage, BlobRegistryImpl& blobRegistry) const
144144{
145145 g_object_set(soupMessage, SOUP_MESSAGE_METHOD, httpMethod().ascii().data(), NULL);
146146

@@void ResourceRequest::updateSoupMessage(SoupMessage* soupMessage) const
148148 soup_message_set_uri(soupMessage, uri.get());
149149
150150 updateSoupMessageMembers(soupMessage);
151  updateSoupMessageBody(soupMessage);
 151 updateSoupMessageBody(soupMessage, blobRegistry);
152152}
153153
154154void ResourceRequest::updateFromSoupMessage(SoupMessage* soupMessage)

Source/WebKit/NetworkProcess/Downloads/DownloadManager.cpp

2727#include "DownloadManager.h"
2828
2929#include "Download.h"
30 #include "NetworkBlobRegistry.h"
3130#include "NetworkConnectionToWebProcess.h"
3231#include "NetworkLoad.h"
3332#include "NetworkSession.h"

@@void DownloadManager::startDownload(PAL::SessionID sessionID, DownloadID downloa
5554 parameters.request = request;
5655 parameters.clientCredentialPolicy = ClientCredentialPolicy::MayAskClientForCredentials;
5756 if (request.url().protocolIsBlob())
58  parameters.blobFileReferences = client().networkBlobRegistry().filesInBlob(request.url());
 57 parameters.blobFileReferences = client().networkSession(sessionID)->blobRegistry().filesInBlob(request.url());
5958 parameters.storedCredentialsPolicy = sessionID.isEphemeral() ? StoredCredentialsPolicy::DoNotUse : StoredCredentialsPolicy::Use;
6059
61  m_pendingDownloads.add(downloadID, std::make_unique<PendingDownload>(m_client.parentProcessConnectionForDownloads(), WTFMove(parameters), downloadID, *networkSession, &client().networkBlobRegistry().blobRegistry(), suggestedName));
 60 m_pendingDownloads.add(downloadID, std::make_unique<PendingDownload>(m_client.parentProcessConnectionForDownloads(), WTFMove(parameters), downloadID, *networkSession, &client().networkSession(sessionID)->blobRegistry(), suggestedName));
6261}
6362
6463void DownloadManager::dataTaskBecameDownloadTask(DownloadID downloadID, std::unique_ptr<Download>&& download)

Source/WebKit/NetworkProcess/Downloads/DownloadManager.h

@@namespace WebKit {
5555
5656class AuthenticationManager;
5757class Download;
58 class NetworkBlobRegistry;
5958class NetworkConnectionToWebProcess;
6059class NetworkLoad;
6160class PendingDownload;

@@public:
7574 virtual AuthenticationManager& downloadsAuthenticationManager() = 0;
7675 virtual void pendingDownloadCanceled(DownloadID) = 0;
7776 virtual NetworkSession* networkSession(const PAL::SessionID&) const = 0;
78  virtual NetworkBlobRegistry& networkBlobRegistry() = 0;
7977 virtual void ref() const = 0;
8078 virtual void deref() const = 0;
8179 virtual uint32_t downloadMonitorSpeedMultiplier() const = 0;

Source/WebKit/NetworkProcess/FileAPI/NetworkBlobRegistry.cpp

@@Vector<RefPtr<BlobDataFileReference>> NetworkBlobRegistry::filesInBlob(NetworkCo
166166 return filesInBlob(url);
167167}
168168
169 Vector<RefPtr<BlobDataFileReference>> NetworkBlobRegistry::filesInBlob(const URL& url)
170 {
171  ASSERT(m_blobRegistry.isBlobRegistryImpl());
172  BlobData* blobData = m_blobRegistry.getBlobDataFromURL(url);
173  if (!blobData)
174  return { };
175 
176  Vector<RefPtr<BlobDataFileReference>> result;
177  for (const BlobDataItem& item : blobData->items()) {
178  if (item.type() == BlobDataItem::Type::File)
179  result.append(item.file());
180  }
181 
182  return result;
183 }
184 
185169}

Source/WebKit/NetworkProcess/FileAPI/NetworkBlobRegistry.h

1 /*
2  * Copyright (C) 2013-2016 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 #pragma once
27 
28 #include <WebCore/BlobRegistryImpl.h>
29 #include <wtf/Function.h>
30 #include <wtf/HashMap.h>
31 #include <wtf/HashSet.h>
32 #include <wtf/URLHash.h>
33 
34 namespace WebCore {
35 class BlobDataFileReference;
36 class BlobPart;
37 }
38 
39 namespace WebKit {
40 
41 class NetworkConnectionToWebProcess;
42 class SandboxExtension;
43 
44 class NetworkBlobRegistry {
45 WTF_MAKE_NONCOPYABLE(NetworkBlobRegistry);
46 public:
47  NetworkBlobRegistry();
48  ~NetworkBlobRegistry();
49 
50  void registerFileBlobURL(NetworkConnectionToWebProcess&, const URL&, const String& path, RefPtr<SandboxExtension>&&, const String& contentType);
51  void registerBlobURL(NetworkConnectionToWebProcess&, const URL&, Vector<WebCore::BlobPart>&&, const String& contentType);
52  void registerBlobURL(NetworkConnectionToWebProcess&, const URL&, const URL& srcURL, bool shouldBypassConnectionCheck);
53  void registerBlobURLOptionallyFileBacked(NetworkConnectionToWebProcess&, const URL&, const URL& srcURL, const String& fileBackedPath, const String& contentType);
54  void registerBlobURLForSlice(NetworkConnectionToWebProcess&, const URL&, const URL& srcURL, int64_t start, int64_t end);
55  void unregisterBlobURL(NetworkConnectionToWebProcess&, const URL&);
56  uint64_t blobSize(NetworkConnectionToWebProcess&, const URL&);
57  void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&&)>&&);
58  void writeBlobToFilePath(const URL& blobURL, const String& path, CompletionHandler<void(bool success)>&&);
59 
60  void connectionToWebProcessDidClose(NetworkConnectionToWebProcess&);
61 
62  Vector<RefPtr<WebCore::BlobDataFileReference>> filesInBlob(NetworkConnectionToWebProcess&, const URL&);
63  Vector<RefPtr<WebCore::BlobDataFileReference>> filesInBlob(const URL&);
64 
65  WebCore::BlobRegistryImpl& blobRegistry() { return m_blobRegistry; }
66 
67 private:
68  typedef HashMap<NetworkConnectionToWebProcess*, HashSet<URL>> BlobForConnectionMap;
69  BlobForConnectionMap m_blobsForConnection;
70  WebCore::BlobRegistryImpl m_blobRegistry;
71 };
72 
73 }

Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

@@void NetworkConnectionToWebProcess::didClose(IPC::Connection& connection)
301301
302302 m_networkProcess->webProcessWasDisconnected(connection);
303303
304  m_networkProcess->networkBlobRegistry().connectionToWebProcessDidClose(*this);
305304 m_networkProcess->removeNetworkConnectionToWebProcess(*this);
306305
307306#if USE(LIBWEBRTC)

@@void NetworkConnectionToWebProcess::endSuspension()
374373
375374Vector<RefPtr<WebCore::BlobDataFileReference>> NetworkConnectionToWebProcess::resolveBlobReferences(const NetworkResourceLoadParameters& parameters)
376375{
 376 auto* session = networkProcess().networkSession(parameters.sessionID);
 377 if (!session)
 378 return { };
 379
 380 auto& blobRegistry = session->blobRegistry();
 381
377382 Vector<RefPtr<WebCore::BlobDataFileReference>> files;
378383 if (auto* body = parameters.request.httpBody()) {
379384 for (auto& element : body->elements()) {
380385 if (auto* blobData = WTF::get_if<FormDataElement::EncodedBlobData>(element.data))
381  files.appendVector(m_networkProcess->networkBlobRegistry().filesInBlob(*this, blobData->url));
 386 files.appendVector(blobRegistry.filesInBlob(blobData->url));
382387 }
383  const_cast<WebCore::ResourceRequest&>(parameters.request).setHTTPBody(body->resolveBlobReferences(m_networkProcess->networkBlobRegistry().blobRegistry()));
 388 const_cast<WebCore::ResourceRequest&>(parameters.request).setHTTPBody(body->resolveBlobReferences(&blobRegistry));
384389 }
385390
386391 return files;

@@void NetworkConnectionToWebProcess::deleteCookie(PAL::SessionID sessionID, const
568573 storageSession(networkProcess(), sessionID).deleteCookie(url, cookieName);
569574}
570575
571 void NetworkConnectionToWebProcess::registerFileBlobURL(const URL& url, const String& path, SandboxExtension::Handle&& extensionHandle, const String& contentType)
 576void NetworkConnectionToWebProcess::registerFileBlobURL(PAL::SessionID sessionID, const URL& url, const String& path, SandboxExtension::Handle&& extensionHandle, const String& contentType)
572577{
573  m_networkProcess->networkBlobRegistry().registerFileBlobURL(*this, url, path, SandboxExtension::create(WTFMove(extensionHandle)), contentType);
 578 auto* session = networkProcess().networkSession(sessionID);
 579 if (!session)
 580 return;
 581
 582 session->blobRegistry().registerFileBlobURL(url, BlobDataFileReferenceWithSandboxExtension::create(path, SandboxExtension::create(WTFMove(extensionHandle))), contentType);
574583}
575584
576 void NetworkConnectionToWebProcess::registerBlobURL(const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
 585void NetworkConnectionToWebProcess::registerBlobURL(PAL::SessionID sessionID, const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
577586{
578  m_networkProcess->networkBlobRegistry().registerBlobURL(*this, url, WTFMove(blobParts), contentType);
 587 auto* session = networkProcess().networkSession(sessionID);
 588 if (!session)
 589 return;
 590
 591 session->blobRegistry().registerBlobURL(url, WTFMove(blobParts), contentType);
579592}
580593
581 void NetworkConnectionToWebProcess::registerBlobURLFromURL(const URL& url, const URL& srcURL, bool shouldBypassConnectionCheck)
 594void NetworkConnectionToWebProcess::registerBlobURLFromURL(PAL::SessionID sessionID, const URL& url, const URL& srcURL)
582595{
583  m_networkProcess->networkBlobRegistry().registerBlobURL(*this, url, srcURL, shouldBypassConnectionCheck);
 596 auto* session = networkProcess().networkSession(sessionID);
 597 if (!session)
 598 return;
 599
 600 session->blobRegistry().registerBlobURL(url, srcURL);
584601}
585602
586 void NetworkConnectionToWebProcess::registerBlobURLOptionallyFileBacked(const URL& url, const URL& srcURL, const String& fileBackedPath, const String& contentType)
 603void NetworkConnectionToWebProcess::registerBlobURLOptionallyFileBacked(PAL::SessionID sessionID, const URL& url, const URL& srcURL, const String& fileBackedPath, const String& contentType)
587604{
588  m_networkProcess->networkBlobRegistry().registerBlobURLOptionallyFileBacked(*this, url, srcURL, fileBackedPath, contentType);
 605 auto* session = networkProcess().networkSession(sessionID);
 606 if (!session)
 607 return;
 608
 609 session->blobRegistry().registerBlobURLOptionallyFileBacked(url, srcURL, BlobDataFileReferenceWithSandboxExtension::create(fileBackedPath, nullptr), contentType);
589610}
590611
591 void NetworkConnectionToWebProcess::registerBlobURLForSlice(const URL& url, const URL& srcURL, int64_t start, int64_t end)
 612void NetworkConnectionToWebProcess::registerBlobURLForSlice(PAL::SessionID sessionID, const URL& url, const URL& srcURL, int64_t start, int64_t end)
592613{
593  m_networkProcess->networkBlobRegistry().registerBlobURLForSlice(*this, url, srcURL, start, end);
 614 auto* session = networkProcess().networkSession(sessionID);
 615 if (!session)
 616 return;
 617
 618 session->blobRegistry().registerBlobURLForSlice(url, srcURL, start, end);
594619}
595620
596 void NetworkConnectionToWebProcess::unregisterBlobURL(const URL& url)
 621void NetworkConnectionToWebProcess::unregisterBlobURL(PAL::SessionID sessionID, const URL& url)
597622{
598  m_networkProcess->networkBlobRegistry().unregisterBlobURL(*this, url);
 623 auto* session = networkProcess().networkSession(sessionID);
 624 if (!session)
 625 return;
 626
 627 session->blobRegistry().unregisterBlobURL(url);
599628}
600629
601630void NetworkConnectionToWebProcess::blobSize(const URL& url, CompletionHandler<void(uint64_t)>&& completionHandler)
602631{
603  completionHandler(m_networkProcess->networkBlobRegistry().blobSize(*this, url));
 632 auto* blobRegistry = networkProcess().blobRegistry(*this);
 633 if (!blobRegistry)
 634 return;
 635
 636 completionHandler(blobRegistry->blobSize(url));
604637}
605638
606 void NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&&)>&& completionHandler)
 639void NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles(PAL::SessionID sessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&&)>&& completionHandler)
607640{
 641 auto* session = networkProcess().networkSession(sessionID);
 642 if (!session)
 643 return;
 644
608645 Vector<RefPtr<BlobDataFileReference>> fileReferences;
609646 for (auto& url : blobURLs)
610  fileReferences.appendVector(m_networkProcess->networkBlobRegistry().filesInBlob(*this, { { }, url }));
 647 fileReferences.appendVector(session->blobRegistry().filesInBlob({ { }, url }));
611648
612649 for (auto& file : fileReferences)
613650 file->prepareForFileAccess();
614651
615  m_networkProcess->networkBlobRegistry().writeBlobsToTemporaryFiles(blobURLs, [fileReferences = WTFMove(fileReferences), completionHandler = WTFMove(completionHandler)](auto&& fileNames) mutable {
 652 session->blobRegistry().writeBlobsToTemporaryFiles(blobURLs, [fileReferences = WTFMove(fileReferences), completionHandler = WTFMove(completionHandler)](auto&& fileNames) mutable {
616653 for (auto& file : fileReferences)
617654 file->revokeFileAccess();
618655 completionHandler(WTFMove(fileNames));
619656 });
620657}
621658
622 Vector<RefPtr<WebCore::BlobDataFileReference>> NetworkConnectionToWebProcess::filesInBlob(const URL& url)
623 {
624  return m_networkProcess->networkBlobRegistry().filesInBlob(*this, url);
625 }
626 
627 WebCore::BlobRegistryImpl& NetworkConnectionToWebProcess::blobRegistry()
628 {
629  return m_networkProcess->networkBlobRegistry().blobRegistry();
630 }
631 
632659void NetworkConnectionToWebProcess::setCaptureExtraNetworkLoadMetricsEnabled(bool enabled)
633660{
634661 m_captureExtraNetworkLoadMetricsEnabled = enabled;

Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h

@@public:
138138 Optional<NetworkActivityTracker> startTrackingResourceLoad(WebCore::PageIdentifier, ResourceLoadIdentifier resourceID, bool isMainResource, const PAL::SessionID&);
139139 void stopTrackingResourceLoad(ResourceLoadIdentifier resourceID, NetworkActivityTracker::CompletionCode);
140140
141  WebCore::BlobRegistryImpl& blobRegistry();
142  Vector<RefPtr<WebCore::BlobDataFileReference>> filesInBlob(const URL&);
143141 Vector<RefPtr<WebCore::BlobDataFileReference>> resolveBlobReferences(const NetworkResourceLoadParameters&);
144142
145143 void webPageWasAdded(PAL::SessionID, WebCore::PageIdentifier, WebCore::PageIdentifier oldPageID);

@@private:
183181 void getRawCookies(PAL::SessionID, const URL& firstParty, const WebCore::SameSiteInfo&, const URL&, Optional<uint64_t> frameID, Optional<WebCore::PageIdentifier>, CompletionHandler<void(Vector<WebCore::Cookie>&&)>&&);
184182 void deleteCookie(PAL::SessionID, const URL&, const String& cookieName);
185183
186  void registerFileBlobURL(const URL&, const String& path, SandboxExtension::Handle&&, const String& contentType);
187  void registerBlobURL(const URL&, Vector<WebCore::BlobPart>&&, const String& contentType);
188  void registerBlobURLFromURL(const URL&, const URL& srcURL, bool shouldBypassConnectionCheck);
189  void registerBlobURLOptionallyFileBacked(const URL&, const URL& srcURL, const String& fileBackedPath, const String& contentType);
190  void registerBlobURLForSlice(const URL&, const URL& srcURL, int64_t start, int64_t end);
 184 void registerFileBlobURL(PAL::SessionID, const URL&, const String& path, SandboxExtension::Handle&&, const String& contentType);
 185 void registerBlobURL(PAL::SessionID, const URL&, Vector<WebCore::BlobPart>&&, const String& contentType);
 186 void registerBlobURLFromURL(PAL::SessionID, const URL&, const URL& srcURL);
 187 void registerBlobURLOptionallyFileBacked(PAL::SessionID, const URL&, const URL& srcURL, const String& fileBackedPath, const String& contentType);
 188 void registerBlobURLForSlice(PAL::SessionID, const URL&, const URL& srcURL, int64_t start, int64_t end);
191189 void blobSize(const URL&, CompletionHandler<void(uint64_t)>&&);
192  void unregisterBlobURL(const URL&);
193  void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&&)>&&);
 190 void unregisterBlobURL(PAL::SessionID, const URL&);
 191 void writeBlobsToTemporaryFiles(PAL::SessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&&)>&&);
194192
195193 void setCaptureExtraNetworkLoadMetricsEnabled(bool);
196194

Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in

@@messages -> NetworkConnectionToWebProcess LegacyReceiver {
4141 GetRawCookies(PAL::SessionID sessionID, URL firstParty, struct WebCore::SameSiteInfo sameSiteInfo, URL url, Optional<uint64_t> frameID, Optional<WebCore::PageIdentifier> pageID) -> (Vector<WebCore::Cookie> cookies) Synchronous
4242 DeleteCookie(PAL::SessionID sessionID, URL url, String cookieName)
4343
44  RegisterFileBlobURL(URL url, String path, WebKit::SandboxExtension::Handle extensionHandle, String contentType)
45  RegisterBlobURL(URL url, Vector<WebCore::BlobPart> blobParts, String contentType)
46  RegisterBlobURLFromURL(URL url, URL srcURL, bool shouldBypassConnectionCheck)
47  RegisterBlobURLOptionallyFileBacked(URL url, URL srcURL, String fileBackedPath, String contentType)
48  RegisterBlobURLForSlice(URL url, URL srcURL, int64_t start, int64_t end)
49  UnregisterBlobURL(URL url)
 44 RegisterFileBlobURL(PAL::SessionID sessionID, URL url, String path, WebKit::SandboxExtension::Handle extensionHandle, String contentType)
 45 RegisterBlobURL(PAL::SessionID sessionID, URL url, Vector<WebCore::BlobPart> blobParts, String contentType)
 46 RegisterBlobURLFromURL(PAL::SessionID sessionID, URL url, URL srcURL)
 47 RegisterBlobURLOptionallyFileBacked(PAL::SessionID sessionID, URL url, URL srcURL, String fileBackedPath, String contentType)
 48 RegisterBlobURLForSlice(PAL::SessionID sessionID, URL url, URL srcURL, int64_t start, int64_t end)
 49 UnregisterBlobURL(PAL::SessionID sessionID, URL url)
5050 BlobSize(URL url) -> (uint64_t resultSize) Synchronous
51  WriteBlobsToTemporaryFiles(Vector<String> blobURLs) -> (Vector<String> fileNames) Async
 51 WriteBlobsToTemporaryFiles(PAL::SessionID sessionID, Vector<String> blobURLs) -> (Vector<String> fileNames) Async
5252
5353 SetCaptureExtraNetworkLoadMetricsEnabled(bool enabled)
5454

Source/WebKit/NetworkProcess/NetworkProcess.cpp

@@void NetworkProcess::destroySession(const PAL::SessionID& sessionID)
612612 m_storageQuotaManagers.remove(sessionID);
613613}
614614
 615BlobRegistryImpl* NetworkProcess::blobRegistry(NetworkConnectionToWebProcess& connection)
 616{
 617 // FIXME: Deprecate this method and use sessionID -> NetworkSession -> blob registry.
 618 auto* session = networkSessionByConnection(connection.connection());
 619 return session ? &session->blobRegistry() : nullptr;
 620}
 621
615622#if ENABLE(RESOURCE_LOAD_STATISTICS)
616623void NetworkProcess::dumpResourceLoadStatistics(PAL::SessionID sessionID, CompletionHandler<void(String)>&& completionHandler)
617624{

Source/WebKit/NetworkProcess/NetworkProcess.h

2929#include "CacheModel.h"
3030#include "DownloadManager.h"
3131#include "LocalStorageDatabaseTracker.h"
32 #include "NetworkBlobRegistry.h"
3332#include "NetworkContentRuleListManager.h"
3433#include "NetworkHTTPSUpgradeChecker.h"
3534#include "SandboxExtension.h"

@@public:
327326 void removeCacheEngine(const PAL::SessionID&);
328327 void requestStorageSpace(PAL::SessionID, const WebCore::ClientOrigin&, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(Optional<uint64_t>)>&&);
329328
330  NetworkBlobRegistry& networkBlobRegistry() override { return m_networkBlobRegistry; }
 329 WebCore::BlobRegistryImpl* blobRegistry(NetworkConnectionToWebProcess&);
331330
332331 void storeAdClickAttribution(PAL::SessionID, WebCore::AdClickAttribution&&);
333332 void dumpAdClickAttribution(PAL::SessionID, CompletionHandler<void(String)>&&);

@@private:
498497 HashMap<PAL::SessionID, std::unique_ptr<NetworkSession>> m_networkSessions;
499498 HashMap<PAL::SessionID, std::unique_ptr<WebCore::NetworkStorageSession>> m_networkStorageSessions;
500499 mutable std::unique_ptr<WebCore::NetworkStorageSession> m_defaultNetworkStorageSession;
501  NetworkBlobRegistry m_networkBlobRegistry;
502500
503501#if PLATFORM(COCOA)
504502 void platformInitializeNetworkProcessCocoa(const NetworkProcessCreationParameters&);

Source/WebKit/NetworkProcess/NetworkProcessPlatformStrategies.cpp

@@BlobRegistry* NetworkProcessPlatformStrategies::createBlobRegistry()
5252{
5353 using namespace WebCore;
5454 class EmptyBlobRegistry : public WebCore::BlobRegistry {
55  void registerFileBlobURL(const URL&, Ref<BlobDataFileReference>&&, const String& contentType) final { ASSERT_NOT_REACHED(); }
56  void registerBlobURL(const URL&, Vector<BlobPart>&&, const String& contentType) final { ASSERT_NOT_REACHED(); }
57  void registerBlobURL(const URL&, const URL& srcURL) final { ASSERT_NOT_REACHED(); }
58  void registerBlobURLOptionallyFileBacked(const URL&, const URL& srcURL, RefPtr<BlobDataFileReference>&&, const String& contentType) final { ASSERT_NOT_REACHED(); }
59  void registerBlobURLForSlice(const URL&, const URL& srcURL, long long start, long long end) final { ASSERT_NOT_REACHED(); }
60  void unregisterBlobURL(const URL&) final { ASSERT_NOT_REACHED(); }
 55 void registerFileBlobURL(PAL::SessionID, const URL&, Ref<BlobDataFileReference>&&, const String& contentType) final { ASSERT_NOT_REACHED(); }
 56 void registerBlobURL(PAL::SessionID, const URL&, Vector<BlobPart>&&, const String& contentType) final { ASSERT_NOT_REACHED(); }
 57 void registerBlobURL(PAL::SessionID, const URL&, const URL& srcURL) final { ASSERT_NOT_REACHED(); }
 58 void registerBlobURLOptionallyFileBacked(PAL::SessionID, const URL&, const URL& srcURL, RefPtr<BlobDataFileReference>&&, const String& contentType) final { ASSERT_NOT_REACHED(); }
 59 void registerBlobURLForSlice(PAL::SessionID, const URL&, const URL& srcURL, long long start, long long end) final { ASSERT_NOT_REACHED(); }
 60 void unregisterBlobURL(PAL::SessionID, const URL&) final { ASSERT_NOT_REACHED(); }
6161 unsigned long long blobSize(const URL&) final { ASSERT_NOT_REACHED(); return 0; }
62  void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&) final { ASSERT_NOT_REACHED(); }
63  bool isBlobRegistryImpl() const { return false; }
 62 void writeBlobsToTemporaryFiles(PAL::SessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&) final { ASSERT_NOT_REACHED(); }
6463 };
6564 static NeverDestroyed<EmptyBlobRegistry> blobRegistry;
6665 return &blobRegistry.get();

Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp

@@void NetworkResourceLoader::startNetworkLoad(ResourceRequest&& request, FirstLoa
300300 if (parameters.storedCredentialsPolicy == WebCore::StoredCredentialsPolicy::Use && m_networkLoadChecker)
301301 parameters.storedCredentialsPolicy = m_networkLoadChecker->storedCredentialsPolicy();
302302
303  if (request.url().protocolIsBlob())
304  parameters.blobFileReferences = m_connection->filesInBlob(originalRequest().url());
305 
306303 auto* networkSession = m_connection->networkProcess().networkSession(parameters.sessionID);
307304 if (!networkSession && parameters.sessionID.isEphemeral()) {
308305 m_connection->networkProcess().addWebsiteDataStore(WebsiteDataStoreParameters::privateSessionParameters(parameters.sessionID));

@@void NetworkResourceLoader::startNetworkLoad(ResourceRequest&& request, FirstLoa
316313 return;
317314 }
318315
 316 if (request.url().protocolIsBlob())
 317 parameters.blobFileReferences = networkSession->blobRegistry().filesInBlob(originalRequest().url());
 318
319319 parameters.request = WTFMove(request);
320  m_networkLoad = std::make_unique<NetworkLoad>(*this, &m_connection->blobRegistry(), WTFMove(parameters), *networkSession);
 320 m_networkLoad = std::make_unique<NetworkLoad>(*this, &networkSession->blobRegistry(), WTFMove(parameters), *networkSession);
321321
322322 RELEASE_LOG_IF_ALLOWED("startNetworkLoad: (pageID = %" PRIu64 ", frameID = %" PRIu64 ", resourceID = %" PRIu64 ", description = %{public}s)", m_parameters.webPageID.toUInt64(), m_parameters.webFrameID, m_parameters.identifier, m_networkLoad->description().utf8().data());
323323}

Source/WebKit/NetworkProcess/NetworkSession.h

2929#include "SandboxExtension.h"
3030#include "WebResourceLoadStatisticsStore.h"
3131#include <WebCore/AdClickAttribution.h>
 32#include <WebCore/BlobRegistryImpl.h>
3233#include <WebCore/RegistrableDomain.h>
3334#include <pal/SessionID.h>
3435#include <wtf/HashSet.h>

@@public:
114115 virtual void removeWebSocketTask(WebSocketTask&) { }
115116 virtual void addWebSocketTask(WebSocketTask&) { }
116117
 118 WebCore::BlobRegistryImpl& blobRegistry() { return m_blobRegistry; }
 119
117120protected:
118121 NetworkSession(NetworkProcess&, const NetworkSessionCreationParameters&);
119122

@@protected:
143146 bool m_isInvalidated { false };
144147#endif
145148 RefPtr<NetworkCache::Cache> m_cache;
 149 WebCore::BlobRegistryImpl m_blobRegistry;
146150};
147151
148152} // namespace WebKit

Source/WebKit/NetworkProcess/soup/NetworkDataTaskSoup.cpp

@@void NetworkDataTaskSoup::createRequest(ResourceRequest&& request)
134134
135135 unsigned messageFlags = SOUP_MESSAGE_NO_REDIRECT;
136136
137  m_currentRequest.updateSoupMessage(soupMessage.get());
 137 m_currentRequest.updateSoupMessage(soupMessage.get(), m_session->blobRegistry());
138138 if (m_shouldContentSniff == ContentSniffingPolicy::DoNotSniffContent)
139139 soup_message_disable_feature(soupMessage.get(), SOUP_TYPE_CONTENT_SNIFFER);
140140 if (m_user.isEmpty() && m_password.isEmpty() && m_storedCredentialsPolicy == StoredCredentialsPolicy::DoNotUse) {

Source/WebKit/NetworkProcess/soup/NetworkSessionSoup.cpp

@@std::unique_ptr<WebSocketTask> NetworkSessionSoup::createWebSocketTask(NetworkSo
121121 return nullptr;
122122
123123 GRefPtr<SoupMessage> soupMessage = adoptGRef(soup_message_new_from_uri(SOUP_METHOD_GET, soupURI.get()));
124  request.updateSoupMessage(soupMessage.get());
 124 request.updateSoupMessage(soupMessage.get(), blobRegistry());
125125 if (request.url().protocolIs("wss"))
126126 g_signal_connect(soupMessage.get(), "network-event", G_CALLBACK(webSocketMessageNetworkEventCallback), nullptr);
127127 return std::make_unique<WebSocketTask>(channel, soupSession(), soupMessage.get(), protocol);

Source/WebKit/Sources.txt

@@NetworkProcess/Downloads/DownloadMap.cpp
5757NetworkProcess/Downloads/DownloadMonitor.cpp
5858NetworkProcess/Downloads/PendingDownload.cpp
5959
60 NetworkProcess/FileAPI/NetworkBlobRegistry.cpp
61 
6260NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
6361
6462NetworkProcess/ServiceWorker/ServiceWorkerFetchTask.cpp @no-unify

Source/WebKit/WebKit.xcodeproj/project.pbxproj

13161316 9FB5F395169E6A80002C25BF /* WKContextPrivateMac.h in Headers */ = {isa = PBXBuildFile; fileRef = 9FB5F393169E6A80002C25BF /* WKContextPrivateMac.h */; settings = {ATTRIBUTES = (Private, ); }; };
13171317 A102A7081EC0EEE900D81D82 /* com.macromedia.Flash Player ESR.plugin.sb in Copy Plug-in Sandbox Profiles */ = {isa = PBXBuildFile; fileRef = 7A5E39491D5BD8A700B4B7CE /* com.macromedia.Flash Player ESR.plugin.sb */; };
13181318 A1046EA12079263100F0C5D8 /* WKPDFView.h in Headers */ = {isa = PBXBuildFile; fileRef = A1046E9F2079263100F0C5D8 /* WKPDFView.h */; };
1319  A105D0D1212734B20034F6C7 /* NetworkBlobRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = A105D0D0212734B10034F6C7 /* NetworkBlobRegistry.h */; };
13201319 A115DC72191D82DA00DA8072 /* _WKWebViewPrintFormatter.h in Headers */ = {isa = PBXBuildFile; fileRef = A115DC6E191D82AB00DA8072 /* _WKWebViewPrintFormatter.h */; settings = {ATTRIBUTES = (Private, ); }; };
13211320 A118A9EF1907AD6F00F7C92B /* QuickLookDocumentData.h in Headers */ = {isa = PBXBuildFile; fileRef = A118A9ED1907AD6F00F7C92B /* QuickLookDocumentData.h */; };
13221321 A118A9F31908B8EA00F7C92B /* _WKNSFileManagerExtras.h in Headers */ = {isa = PBXBuildFile; fileRef = A118A9F11908B8EA00F7C92B /* _WKNSFileManagerExtras.h */; settings = {ATTRIBUTES = (Private, ); }; };

39853984 9FB5F393169E6A80002C25BF /* WKContextPrivateMac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = WKContextPrivateMac.h; path = mac/WKContextPrivateMac.h; sourceTree = "<group>"; };
39863985 A1046E9F2079263100F0C5D8 /* WKPDFView.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = WKPDFView.h; path = ios/WKPDFView.h; sourceTree = "<group>"; };
39873986 A1046EA02079263100F0C5D8 /* WKPDFView.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; name = WKPDFView.mm; path = ios/WKPDFView.mm; sourceTree = "<group>"; };
3988  A105D0D0212734B10034F6C7 /* NetworkBlobRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkBlobRegistry.h; sourceTree = "<group>"; };
39893987 A115DC6D191D82AB00DA8072 /* _WKWebViewPrintFormatter.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = _WKWebViewPrintFormatter.mm; sourceTree = "<group>"; };
39903988 A115DC6E191D82AB00DA8072 /* _WKWebViewPrintFormatter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKWebViewPrintFormatter.h; sourceTree = "<group>"; };
39913989 A118A9EC1907AD6F00F7C92B /* QuickLookDocumentData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = QuickLookDocumentData.cpp; path = ios/QuickLookDocumentData.cpp; sourceTree = "<group>"; };

46194617 E164A2F0191AF14E0010737D /* BlobDataFileReferenceWithSandboxExtension.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = BlobDataFileReferenceWithSandboxExtension.h; sourceTree = "<group>"; };
46204618 E170876916D6CA6900F99226 /* BlobRegistryProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = BlobRegistryProxy.cpp; path = WebProcess/FileAPI/BlobRegistryProxy.cpp; sourceTree = "<group>"; };
46214619 E170876A16D6CA6900F99226 /* BlobRegistryProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = BlobRegistryProxy.h; path = WebProcess/FileAPI/BlobRegistryProxy.h; sourceTree = "<group>"; };
4622  E1798C7716E6818800240139 /* NetworkBlobRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkBlobRegistry.cpp; sourceTree = "<group>"; };
46234620 E17AE2C116B9C139001C42F1 /* com.apple.WebKit.NetworkProcess.sb.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = com.apple.WebKit.NetworkProcess.sb.in; sourceTree = "<group>"; };
46244621 E17AE2C216B9C63A001C42F1 /* com.apple.WebKit.NetworkProcess.sb */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = com.apple.WebKit.NetworkProcess.sb; path = DerivedSources/WebKit2/com.apple.WebKit.NetworkProcess.sb; sourceTree = BUILT_PRODUCTS_DIR; };
46254622 E18C92F312DB9E7100CF2AEB /* PrintInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PrintInfo.cpp; sourceTree = "<group>"; };

66646661 5C1426F21C23F82D00D41183 /* CustomProtocols */,
66656662 5C1426F11C23F81700D41183 /* Downloads */,
66666663 BC82837C16B45DA500A278FE /* EntryPoint */,
6667  E1798C7616E6815500240139 /* FileAPI */,
66686664 939288E021404DF000EBBA33 /* IndexedDB */,
66696665 2DA944BB188511DD00ED86DB /* ios */,
66706666 510CC7DC16138E2900D03ED3 /* mac */,

90249020 name = FileAPI;
90259021 sourceTree = "<group>";
90269022 };
9027  E1798C7616E6815500240139 /* FileAPI */ = {
9028  isa = PBXGroup;
9029  children = (
9030  E1798C7716E6818800240139 /* NetworkBlobRegistry.cpp */,
9031  A105D0D0212734B10034F6C7 /* NetworkBlobRegistry.h */,
9032  );
9033  path = FileAPI;
9034  sourceTree = "<group>";
9035  };
90369023 E199875B142BF9CF00BB2DE7 /* PDF */ = {
90379024 isa = PBXGroup;
90389025 children = (

94809467 1A4A9C5612B816CF008FE984 /* NetscapePluginModule.h in Headers */,
94819468 1AA5889211EE70400061B882 /* NetscapePluginStream.h in Headers */,
94829469 535BCB922069C49C00CCCE02 /* NetworkActivityTracker.h in Headers */,
9483  A105D0D1212734B20034F6C7 /* NetworkBlobRegistry.h in Headers */,
94849470 E4436ECC1A0D040B00EAD204 /* NetworkCache.h in Headers */,
94859471 E49D40D71AD3FB170066B7B9 /* NetworkCacheBlobStorage.h in Headers */,
94869472 E489D28C1A0A2DB80078C06A /* NetworkCacheCoders.h in Headers */,

Source/WebKit/WebProcess/FileAPI/BlobRegistryProxy.cpp

3636namespace WebKit {
3737using namespace WebCore;
3838
39 void BlobRegistryProxy::registerFileBlobURL(const URL& url, Ref<BlobDataFileReference>&& file, const String& contentType)
 39void BlobRegistryProxy::registerFileBlobURL(PAL::SessionID sessionID, const URL& url, Ref<BlobDataFileReference>&& file, const String& contentType)
4040{
4141 SandboxExtension::Handle extensionHandle;
4242

@@void BlobRegistryProxy::registerFileBlobURL(const URL& url, Ref<BlobDataFileRefe
4444 if (!file->path().isEmpty())
4545 SandboxExtension::createHandle(file->path(), SandboxExtension::Type::ReadOnly, extensionHandle);
4646
47  WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterFileBlobURL(url, file->path(), extensionHandle, contentType), 0);
 47 WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterFileBlobURL(sessionID, url, file->path(), extensionHandle, contentType), 0);
4848}
4949
50 void BlobRegistryProxy::registerBlobURL(const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
 50void BlobRegistryProxy::registerBlobURL(PAL::SessionID sessionID, const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
5151{
52  WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterBlobURL(url, blobParts, contentType), 0);
 52 WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterBlobURL(sessionID, url, blobParts, contentType), 0);
5353}
5454
55 void BlobRegistryProxy::registerBlobURL(const URL& url, const URL& srcURL)
 55void BlobRegistryProxy::registerBlobURL(PAL::SessionID sessionID, const URL& url, const URL& srcURL)
5656{
57  bool shouldBypassConnectionCheck = false;
58 #if ENABLE(SERVICE_WORKER)
59  shouldBypassConnectionCheck = SWContextManager::singleton().connection();
60 #endif
61  WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterBlobURLFromURL { url, srcURL, shouldBypassConnectionCheck }, 0);
 57 WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterBlobURLFromURL { sessionID, url, srcURL }, 0);
6258}
6359
64 void BlobRegistryProxy::registerBlobURLOptionallyFileBacked(const URL& url, const URL& srcURL, RefPtr<WebCore::BlobDataFileReference>&& file, const String& contentType)
 60void BlobRegistryProxy::registerBlobURLOptionallyFileBacked(PAL::SessionID sessionID, const URL& url, const URL& srcURL, RefPtr<WebCore::BlobDataFileReference>&& file, const String& contentType)
6561{
6662 ASSERT(file);
67  WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterBlobURLOptionallyFileBacked(url, srcURL, file->path(), contentType), 0);
 63 WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterBlobURLOptionallyFileBacked(sessionID, url, srcURL, file->path(), contentType), 0);
6864}
6965
70 void BlobRegistryProxy::unregisterBlobURL(const URL& url)
 66void BlobRegistryProxy::unregisterBlobURL(PAL::SessionID sessionID, const URL& url)
7167{
72  WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::UnregisterBlobURL(url), 0);
 68 WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::UnregisterBlobURL(sessionID, url), 0);
7369}
7470
75 void BlobRegistryProxy::registerBlobURLForSlice(const URL& url, const URL& srcURL, long long start, long long end)
 71void BlobRegistryProxy::registerBlobURLForSlice(PAL::SessionID sessionID, const URL& url, const URL& srcURL, long long start, long long end)
7672{
77  WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterBlobURLForSlice(url, srcURL, start, end), 0);
 73 WebProcess::singleton().ensureNetworkProcessConnection().connection().send(Messages::NetworkConnectionToWebProcess::RegisterBlobURLForSlice(sessionID, url, srcURL, start, end), 0);
7874}
7975
8076unsigned long long BlobRegistryProxy::blobSize(const URL& url)

@@unsigned long long BlobRegistryProxy::blobSize(const URL& url)
8581 return resultSize;
8682}
8783
88 void BlobRegistryProxy::writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&& completionHandler)
 84void BlobRegistryProxy::writeBlobsToTemporaryFiles(PAL::SessionID sessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&& completionHandler)
8985{
90  WebProcess::singleton().ensureNetworkProcessConnection().writeBlobsToTemporaryFiles(blobURLs, WTFMove(completionHandler));
 86 WebProcess::singleton().ensureNetworkProcessConnection().writeBlobsToTemporaryFiles(sessionID, blobURLs, WTFMove(completionHandler));
9187}
9288
9389}

Source/WebKit/WebProcess/FileAPI/BlobRegistryProxy.h

@@namespace WebKit {
3131
3232class BlobRegistryProxy final : public WebCore::BlobRegistry {
3333public:
34  void registerFileBlobURL(const URL&, Ref<WebCore::BlobDataFileReference>&&, const String& contentType) override;
35  void registerBlobURL(const URL&, Vector<WebCore::BlobPart>&&, const String& contentType) override;
36  void registerBlobURL(const URL&, const URL& srcURL) override;
37  void registerBlobURLOptionallyFileBacked(const URL&, const URL& srcURL, RefPtr<WebCore::BlobDataFileReference>&&, const String& contentType) override;
38  void unregisterBlobURL(const URL&) override;
39  void registerBlobURLForSlice(const URL&, const URL& srcURL, long long start, long long end) override;
40  unsigned long long blobSize(const URL&) override;
41  void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&) override;
 34 void registerFileBlobURL(PAL::SessionID, const URL&, Ref<WebCore::BlobDataFileReference>&&, const String& contentType) final;
 35 void registerBlobURL(PAL::SessionID, const URL&, Vector<WebCore::BlobPart>&&, const String& contentType) final;
 36 void registerBlobURL(PAL::SessionID, const URL&, const URL& srcURL) final;
 37 void registerBlobURLOptionallyFileBacked(PAL::SessionID, const URL&, const URL& srcURL, RefPtr<WebCore::BlobDataFileReference>&&, const String& contentType) final;
 38 void unregisterBlobURL(PAL::SessionID, const URL&) final;
 39 void registerBlobURLForSlice(PAL::SessionID, const URL&, const URL& srcURL, long long start, long long end) final;
 40 unsigned long long blobSize(const URL&) final;
 41 void writeBlobsToTemporaryFiles(PAL::SessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&) final;
4242};
4343
4444}

Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp

@@void NetworkProcessConnection::didReceiveInvalidMessage(IPC::Connection&, IPC::S
211211{
212212}
213213
214 void NetworkProcessConnection::writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&& completionHandler)
 214void NetworkProcessConnection::writeBlobsToTemporaryFiles(PAL::SessionID sessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&& completionHandler)
215215{
216  WebProcess::singleton().ensureNetworkProcessConnection().connection().sendWithAsyncReply(Messages::NetworkConnectionToWebProcess::WriteBlobsToTemporaryFiles(blobURLs), WTFMove(completionHandler));
 216 WebProcess::singleton().ensureNetworkProcessConnection().connection().sendWithAsyncReply(Messages::NetworkConnectionToWebProcess::WriteBlobsToTemporaryFiles(sessionID, blobURLs), WTFMove(completionHandler));
217217}
218218
219219void NetworkProcessConnection::didFinishPingLoad(uint64_t pingLoadIdentifier, ResourceError&& error, ResourceResponse&& response)

Source/WebKit/WebProcess/Network/NetworkProcessConnection.h

@@public:
6565
6666 void didReceiveNetworkProcessConnectionMessage(IPC::Connection&, IPC::Decoder&);
6767
68  void writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&);
 68 void writeBlobsToTemporaryFiles(PAL::SessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&&);
6969
7070#if ENABLE(INDEXED_DATABASE)
7171 WebIDBConnectionToServer* existingIDBConnectionToServerForIdentifier(uint64_t identifier) const { return m_webIDBConnectionsByIdentifier.get(identifier); };

Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm

@@PasteboardStrategy* WebPlatformStrategies::createPasteboardStrategy()
6262 return this;
6363}
6464
 65class WebBlobRegistry final : public BlobRegistry {
 66private:
 67 void registerFileBlobURL(PAL::SessionID, const URL& url, Ref<BlobDataFileReference>&& reference, const String& contentType) final { m_blobRegistry.registerFileBlobURL(url, WTFMove(reference), contentType); }
 68 void registerBlobURL(PAL::SessionID, const URL& url, Vector<BlobPart>&& parts, const String& contentType) final { m_blobRegistry.registerBlobURL(url, WTFMove(parts), contentType); }
 69 void registerBlobURL(PAL::SessionID, const URL& url, const URL& srcURL) final { m_blobRegistry.registerBlobURL(url, srcURL); }
 70 void registerBlobURLOptionallyFileBacked(PAL::SessionID, const URL& url, const URL& srcURL, RefPtr<BlobDataFileReference>&& reference, const String& contentType) final { m_blobRegistry.registerBlobURLOptionallyFileBacked(url, srcURL, WTFMove(reference), contentType); }
 71 void registerBlobURLForSlice(PAL::SessionID, const URL& url, const URL& srcURL, long long start, long long end) final { m_blobRegistry.registerBlobURLForSlice(url, srcURL, start, end); }
 72 void unregisterBlobURL(PAL::SessionID, const URL& url) final { m_blobRegistry.unregisterBlobURL(url); }
 73 unsigned long long blobSize(const URL& url) final { return m_blobRegistry.blobSize(url); }
 74 void writeBlobsToTemporaryFiles(PAL::SessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&& completionHandler) final { m_blobRegistry.writeBlobsToTemporaryFiles(blobURLs, WTFMove(completionHandler)); }
 75
 76 BlobRegistryImpl* blobRegistryImpl() final { return &m_blobRegistry; }
 77
 78 BlobRegistryImpl m_blobRegistry;
 79};
 80
6581BlobRegistry* WebPlatformStrategies::createBlobRegistry()
6682{
67  return new WebCore::BlobRegistryImpl;
 83 return new WebBlobRegistry;
6884}
6985
7086void WebPlatformStrategies::getTypes(Vector<String>& types, const String& pasteboardName)

Source/WebKitLegacy/win/WebCoreSupport/WebPlatformStrategies.cpp

2727
2828#include "WebFrameNetworkingContext.h"
2929#include "WebResourceLoadScheduler.h"
 30#include <WebCore/BlobRegistry.h>
3031#include <WebCore/BlobRegistryImpl.h>
3132#include <WebCore/FrameLoader.h>
3233#include <WebCore/NetworkStorageSession.h>

@@PasteboardStrategy* WebPlatformStrategies::createPasteboardStrategy()
5960 return nullptr;
6061}
6162
 63class WebBlobRegistry final : public BlobRegistry {
 64private:
 65 void registerFileBlobURL(PAL::SessionID, const URL& url, Ref<BlobDataFileReference>&& reference, const String& contentType) final { m_blobRegistry.registerFileBlobURL(url, WTFMove(reference), contentType); }
 66 void registerBlobURL(PAL::SessionID, const URL& url, Vector<BlobPart>&& parts, const String& contentType) final { m_blobRegistry.registerBlobURL(url, WTFMove(parts), contentType); }
 67 void registerBlobURL(PAL::SessionID, const URL& url, const URL& srcURL) final { m_blobRegistry.registerBlobURL(url, srcURL); }
 68 void registerBlobURLOptionallyFileBacked(PAL::SessionID, const URL& url, const URL& srcURL, RefPtr<BlobDataFileReference>&& reference, const String& contentType) final { m_blobRegistry.registerBlobURLOptionallyFileBacked(url, srcURL, WTFMove(reference), contentType); }
 69 void registerBlobURLForSlice(PAL::SessionID, const URL& url, const URL& srcURL, long long start, long long end) final { m_blobRegistry.registerBlobURLForSlice(url, srcURL, start, end); }
 70 void unregisterBlobURL(PAL::SessionID, const URL& url) final { m_blobRegistry.unregisterBlobURL(url); }
 71 unsigned long long blobSize(const URL& url) final { return m_blobRegistry.blobSize(url); }
 72 void writeBlobsToTemporaryFiles(PAL::SessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&& completionHandler) final { m_blobRegistry.writeBlobsToTemporaryFiles(blobURLs, WTFMove(completionHandler)); }
 73
 74 BlobRegistryImpl* blobRegistryImpl() final { return &m_blobRegistry; }
 75
 76 BlobRegistryImpl m_blobRegistry;
 77};
 78
6279BlobRegistry* WebPlatformStrategies::createBlobRegistry()
6380{
64  return new BlobRegistryImpl;
 81 return new WebBlobRegistry;
6582}