Changeset 248593 in webkit


Ignore:
Timestamp:
Aug 13, 2019 3:06:16 AM (5 years ago)
Author:
youenn@apple.com
Message:

Blob registries should be keyed by session IDs
https://bugs.webkit.org/show_bug.cgi?id=200567
Source/WebCore:

<rdar://problem/54120212>

Reviewed by Alex Christensen.

Pass session IDs to all BlobRegistry methods in particular ThreadableLoaderRegistry.
The only exception is blobSize which should be dealt with a follow-up patch.
blobSize blob registry is retrieved from the connection -> sessionID map in Network Process.
Covered by existing tests.

  • Modules/fetch/FetchLoader.cpp:

(WebCore::FetchLoader::~FetchLoader):
(WebCore::FetchLoader::startLoadingBlobURL):

  • Modules/fetch/FetchLoader.h:
  • fileapi/FileReaderLoader.cpp:

(WebCore::FileReaderLoader::~FileReaderLoader):
(WebCore::FileReaderLoader::start):

  • fileapi/FileReaderLoader.h:
  • fileapi/ThreadableBlobRegistry.cpp:

(WebCore::ThreadableBlobRegistry::registerFileBlobURL):
(WebCore::ThreadableBlobRegistry::registerBlobURL):
(WebCore::ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked):

  • fileapi/ThreadableBlobRegistry.h:
  • html/PublicURLManager.cpp:
  • loader/PolicyChecker.cpp:

(WebCore::PolicyChecker::extendBlobURLLifetimeIfNecessary const):

  • platform/network/BlobRegistry.h:
  • platform/network/BlobRegistryImpl.cpp:

(WebCore::createBlobResourceHandle):
(WebCore::loadBlobResourceSynchronously):
(WebCore::BlobRegistryImpl::filesInBlob const):

  • platform/network/BlobRegistryImpl.h:
  • platform/network/FormData.cpp:

(WebCore::appendBlobResolved):
(WebCore::FormData::resolveBlobReferences):

  • platform/network/FormData.h:
  • platform/network/cf/FormDataStreamCFNet.cpp:

(WebCore::createHTTPBodyCFReadStream):

  • platform/network/soup/ResourceRequest.h:
  • platform/network/soup/ResourceRequestSoup.cpp:

(WebCore::ResourceRequest::updateSoupMessageBody const):
(WebCore::ResourceRequest::updateSoupMessage const):

Source/WebKit:

<rdar://problem/54120212>

Reviewed by Alex Christensen.

Move blob registry to NetworkSession so that it is partitioned by session ID.
In case session ID is not given through IPC, use the connection as key to get the network session.
This is used for blobSize.

  • NetworkProcess/Downloads/DownloadManager.cpp:

(WebKit::DownloadManager::startDownload):

  • NetworkProcess/Downloads/DownloadManager.h:
  • NetworkProcess/FileAPI/NetworkBlobRegistry.cpp:
  • NetworkProcess/FileAPI/NetworkBlobRegistry.h: Removed.
  • NetworkProcess/NetworkConnectionToWebProcess.cpp:

(WebKit::NetworkConnectionToWebProcess::didClose):
(WebKit::NetworkConnectionToWebProcess::resolveBlobReferences):
(WebKit::NetworkConnectionToWebProcess::registerFileBlobURL):
(WebKit::NetworkConnectionToWebProcess::registerBlobURL):
(WebKit::NetworkConnectionToWebProcess::registerBlobURLFromURL):
(WebKit::NetworkConnectionToWebProcess::registerBlobURLOptionallyFileBacked):
(WebKit::NetworkConnectionToWebProcess::registerBlobURLForSlice):
(WebKit::NetworkConnectionToWebProcess::unregisterBlobURL):
(WebKit::NetworkConnectionToWebProcess::blobSize):
(WebKit::NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles):
(WebKit::NetworkConnectionToWebProcess::filesInBlob):

  • NetworkProcess/NetworkConnectionToWebProcess.h:
  • NetworkProcess/NetworkConnectionToWebProcess.messages.in:
  • NetworkProcess/NetworkProcess.cpp:

(WebKit::NetworkProcess::blobRegistry):

  • NetworkProcess/NetworkProcess.h:
  • NetworkProcess/NetworkProcessPlatformStrategies.cpp:

(WebKit::NetworkProcessPlatformStrategies::createBlobRegistry):

  • NetworkProcess/NetworkResourceLoader.cpp:

(WebKit::NetworkResourceLoader::startNetworkLoad):

  • NetworkProcess/NetworkSession.h:

(WebKit::NetworkSession::blobRegistry):

  • NetworkProcess/soup/NetworkDataTaskSoup.cpp:

(WebKit::NetworkDataTaskSoup::createRequest):

  • NetworkProcess/soup/NetworkSessionSoup.cpp:

(WebKit::NetworkSessionSoup::createWebSocketTask):

  • Sources.txt:
  • WebKit.xcodeproj/project.pbxproj:
  • WebProcess/FileAPI/BlobRegistryProxy.cpp:

(WebKit::BlobRegistryProxy::registerFileBlobURL):
(WebKit::BlobRegistryProxy::registerBlobURL):
(WebKit::BlobRegistryProxy::registerBlobURLOptionallyFileBacked):
(WebKit::BlobRegistryProxy::unregisterBlobURL):
(WebKit::BlobRegistryProxy::registerBlobURLForSlice):
(WebKit::BlobRegistryProxy::writeBlobsToTemporaryFiles):

  • WebProcess/FileAPI/BlobRegistryProxy.h:
  • WebProcess/Network/NetworkProcessConnection.cpp:

(WebKit::NetworkProcessConnection::writeBlobsToTemporaryFiles):

  • WebProcess/Network/NetworkProcessConnection.h:

Source/WebKitLegacy/mac:

Reviewed by Alex Christensen.

  • WebCoreSupport/WebPlatformStrategies.mm:

(WebPlatformStrategies::createBlobRegistry):
Ignore sessionID parameter for WK1.

Source/WebKitLegacy/win:

<rdar://problem/54120212>

Reviewed by Alex Christensen.

  • WebCoreSupport/WebPlatformStrategies.cpp:

(WebPlatformStrategies::createBlobRegistry):

Location:
trunk/Source
Files:
1 deleted
45 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r248592 r248593  
     12019-08-13  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 Alex Christensen.
     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-13  Youenn Fablet  <youenn@apple.com>
    248
  • trunk/Source/WebCore/Modules/fetch/FetchLoader.cpp

    r233668 r248593  
    4949{
    5050    if (!m_urlForReading.isEmpty())
    51         ThreadableBlobRegistry::unregisterBlobURL(m_urlForReading);
     51        ThreadableBlobRegistry::unregisterBlobURL(*m_sessionID, m_urlForReading);
    5252}
    5353
     
    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);
  • trunk/Source/WebCore/Modules/fetch/FetchLoader.h

    r238771 r248593  
    6868    bool m_isStarted { false };
    6969    URL m_urlForReading;
     70    Optional<PAL::SessionID> m_sessionID;
    7071};
    7172
  • trunk/Source/WebCore/bindings/js/SerializedScriptValue.cpp

    r248527 r248593  
    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
     
    35873586
    35883587        ASSERT(m_blobURLs.size() == blobFilePaths.size());
    3589        
     3588
    35903589        completionHandler({ *this, m_blobURLs, blobFilePaths });
    35913590    });
  • trunk/Source/WebCore/fileapi/Blob.cpp

    r248538 r248593  
    5959{
    6060    ASSERT(&blob.registry() == this);
    61     ThreadableBlobRegistry::registerBlobURL(context.securityOrigin(), publicURL, static_cast<Blob&>(blob).url());
    62 }
    63 
    64 void BlobURLRegistry::unregisterURL(ScriptExecutionContext&, const URL& url)
    65 {
    66     ThreadableBlobRegistry::unregisterBlobURL(url);
     61    ThreadableBlobRegistry::registerBlobURL(context.sessionID(), context.securityOrigin(), publicURL, static_cast<Blob&>(blob).url());
     62}
     63
     64void BlobURLRegistry::unregisterURL(ScriptExecutionContext& context, const URL& url)
     65{
     66    ThreadableBlobRegistry::unregisterBlobURL(context.sessionID(), url);
    6767}
    6868
     
    8585{
    8686    m_internalURL = BlobURL::createInternalURL();
    87     ThreadableBlobRegistry::registerBlobURL(m_internalURL, { },  { });
     87    ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, { },  { });
    8888}
    8989
     
    102102    }
    103103
    104     ThreadableBlobRegistry::registerBlobURL(m_internalURL, builder.finalize(), m_type);
     104    ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, builder.finalize(), m_type);
    105105}
    106106
     
    116116    blobParts.append(BlobPart(WTFMove(data)));
    117117    m_internalURL = BlobURL::createInternalURL();
    118     ThreadableBlobRegistry::registerBlobURL(m_internalURL, WTFMove(blobParts), contentType);
     118    ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, WTFMove(blobParts), contentType);
    119119}
    120120
     
    127127    blobParts.append(BlobPart(WTFMove(data)));
    128128    m_internalURL = BlobURL::createInternalURL();
    129     ThreadableBlobRegistry::registerBlobURL(m_internalURL, WTFMove(blobParts), contentType);
     129    ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, WTFMove(blobParts), contentType);
    130130}
    131131
     
    136136    , m_size(blob.size())
    137137{
    138     ThreadableBlobRegistry::registerBlobURL(m_internalURL, { BlobPart(blob.url()) } , m_type);
     138    ThreadableBlobRegistry::registerBlobURL(m_sessionID, m_internalURL, { BlobPart(blob.url()) } , m_type);
    139139}
    140140
     
    146146    m_internalURL = BlobURL::createInternalURL();
    147147    if (fileBackedPath.isEmpty())
    148         ThreadableBlobRegistry::registerBlobURL(nullptr, m_internalURL, srcURL);
     148        ThreadableBlobRegistry::registerBlobURL(m_sessionID, nullptr, m_internalURL, srcURL);
    149149    else
    150         ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked(m_internalURL, srcURL, fileBackedPath, m_type);
     150        ThreadableBlobRegistry::registerBlobURLOptionallyFileBacked(m_sessionID, m_internalURL, srcURL, fileBackedPath, m_type);
    151151}
    152152
     
    157157{
    158158    m_internalURL = BlobURL::createInternalURL();
    159     ThreadableBlobRegistry::registerBlobURLForSlice(m_internalURL, srcURL, start, end);
     159    ThreadableBlobRegistry::registerBlobURLForSlice(m_sessionID, m_internalURL, srcURL, start, end);
    160160}
    161161
    162162Blob::~Blob()
    163163{
    164     ThreadableBlobRegistry::unregisterBlobURL(m_internalURL);
     164    ThreadableBlobRegistry::unregisterBlobURL(m_sessionID, m_internalURL);
    165165}
    166166
  • trunk/Source/WebCore/fileapi/File.cpp

    r248538 r248593  
    5454
    5555    auto internalURL = BlobURL::createInternalURL();
    56     ThreadableBlobRegistry::registerFileBlobURL(internalURL, path, type);
     56    ThreadableBlobRegistry::registerFileBlobURL(sessionID, internalURL, path, type);
    5757
    5858    return adoptRef(*new File(sessionID, WTFMove(internalURL), WTFMove(type), String { path }, WTFMove(name)));
  • trunk/Source/WebCore/fileapi/FileReaderLoader.cpp

    r239535 r248593  
    6969    terminate();
    7070    if (!m_urlForReading.isEmpty())
    71         ThreadableBlobRegistry::unregisterBlobURL(m_urlForReading);
     71        ThreadableBlobRegistry::unregisterBlobURL(*m_sessionID, m_urlForReading);
    7272}
    7373
     
    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.
  • trunk/Source/WebCore/fileapi/FileReaderLoader.h

    r246964 r248593  
    3636#include "TextEncoding.h"
    3737#include "ThreadableLoaderClient.h"
     38#include <pal/SessionID.h>
    3839#include <wtf/Forward.h>
    3940#include <wtf/text/WTFString.h>
     
    103104
    104105    URL m_urlForReading;
     106    Optional<PAL::SessionID> m_sessionID;
    105107    RefPtr<ThreadableLoader> m_loader;
    106108
  • trunk/Source/WebCore/fileapi/ThreadableBlobRegistry.cpp

    r236101 r248593  
    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     });
     69    if (isMainThread()) {
     70        blobRegistry().registerFileBlobURL(sessionID, url, BlobDataFileReference::create(path), contentType);
     71        return;
     72    }
    7473
    75     queue->append(WTFMove(task));
    76 
    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)
     79void ThreadableBlobRegistry::registerBlobURL(PAL::SessionID sessionID, const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
    8580{
    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         });
     81    if (isMainThread()) {
     82        blobRegistry().registerBlobURL(sessionID, url, WTFMove(blobParts), contentType);
     83        return;
    9284    }
     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    });
    9390}
    9491
    95 void ThreadableBlobRegistry::registerBlobURL(const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
    96 {
    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         });
    105     }
    106 }
    107 
    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.
     
    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{
     133    if (isMainThread())
     134        return blobRegistry().blobSize(url);
     135
    144136    unsigned long long resultSize;
    145     if (isMainThread())
     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
  • trunk/Source/WebCore/fileapi/ThreadableBlobRegistry.h

    r238771 r248593  
    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&);
  • trunk/Source/WebCore/html/PublicURLManager.cpp

    r248473 r248593  
    2727#include "config.h"
    2828#include "PublicURLManager.h"
     29
     30#include "URLRegistry.h"
    2931#include <wtf/URL.h>
    30 #include "URLRegistry.h"
    3132#include <wtf/text/StringHash.h>
    3233
  • trunk/Source/WebCore/loader/PolicyChecker.cpp

    r241842 r248593  
    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}
  • trunk/Source/WebCore/platform/network/BlobRegistry.h

    r238771 r248593  
    3232#pragma once
    3333
     34#include <pal/SessionID.h>
    3435#include <wtf/Forward.h>
    3536
     
    3940class BlobPart;
    4041class BlobRegistry;
     42class BlobRegistryImpl;
    4143
    4244WEBCORE_EXPORT BlobRegistry& blobRegistry();
     
    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:
  • trunk/Source/WebCore/platform/network/BlobRegistryImpl.cpp

    r243163 r248593  
    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}
     
    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
  • trunk/Source/WebCore/platform/network/BlobRegistryImpl.h

    r241008 r248593  
    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:
     
    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 {
     
    7776
    7877    bool populateBlobsForFileWriting(const Vector<String>& blobURLs, Vector<BlobForFileWriting>&);
     78    Vector<RefPtr<BlobDataFileReference>> filesInBlob(const URL&) const;
    7979
    8080private:
  • trunk/Source/WebCore/platform/network/FormData.cpp

    r248139 r248593  
    287287}
    288288
    289 static void appendBlobResolved(BlobRegistry& blobRegistry, FormData& formData, const URL& url)
    290 {
    291     if (!blobRegistry.isBlobRegistryImpl()) {
     289static void appendBlobResolved(BlobRegistryImpl* blobRegistry, FormData& formData, const URL& url)
     290{
     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");
     
    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.
  • trunk/Source/WebCore/platform/network/FormData.h

    r248139 r248593  
    3030namespace WebCore {
    3131
    32 class BlobRegistry;
     32class BlobRegistryImpl;
    3333class DOMFormData;
    3434class File;
     
    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();
  • trunk/Source/WebCore/platform/network/cf/FormDataStreamCFNet.cpp

    r248139 r248593  
    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
  • trunk/Source/WebCore/platform/network/curl/CurlFormDataStream.cpp

    r242842 r248593  
    5252
    5353    // Resolve the blob elements so the formData can correctly report it's size.
    54     m_formData = m_formData->resolveBlobReferences(blobRegistry());
     54    m_formData = m_formData->resolveBlobReferences(blobRegistry().blobRegistryImpl());
    5555}
    5656
  • trunk/Source/WebCore/platform/network/soup/ResourceRequest.h

    r246677 r248593  
    3333
    3434namespace WebCore {
     35
     36    class BlobRegistryImpl;
    3537
    3638    class ResourceRequest : public ResourceRequestBase {
     
    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;
     
    112114
    113115        void updateSoupMessageMembers(SoupMessage*) const;
    114         void updateSoupMessageBody(SoupMessage*) const;
     116        void updateSoupMessageBody(SoupMessage*, BlobRegistryImpl&) const;
    115117        void doUpdatePlatformRequest() { }
    116118        void doUpdateResourceRequest() { }
  • trunk/Source/WebCore/platform/network/soup/ResourceRequestSoup.cpp

    r246102 r248593  
    6969}
    7070
    71 void ResourceRequest::updateSoupMessageBody(SoupMessage* soupMessage) const
     71void ResourceRequest::updateSoupMessageBody(SoupMessage* soupMessage, BlobRegistryImpl& blobRegistry) const
    7272{
    7373    auto* formData = httpBody();
     
    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);
     
    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);
     
    149149
    150150    updateSoupMessageMembers(soupMessage);
    151     updateSoupMessageBody(soupMessage);
     151    updateSoupMessageBody(soupMessage, blobRegistry);
    152152}
    153153
  • trunk/Source/WebKit/ChangeLog

    r248592 r248593  
     12019-08-13  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 Alex Christensen.
     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-13  Youenn Fablet  <youenn@apple.com>
    260
  • trunk/Source/WebKit/NetworkProcess/Downloads/DownloadManager.cpp

    r243110 r248593  
    2828
    2929#include "Download.h"
    30 #include "NetworkBlobRegistry.h"
    3130#include "NetworkConnectionToWebProcess.h"
    3231#include "NetworkLoad.h"
     
    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
  • trunk/Source/WebKit/NetworkProcess/Downloads/DownloadManager.h

    r243110 r248593  
    5656class AuthenticationManager;
    5757class Download;
    58 class NetworkBlobRegistry;
    5958class NetworkConnectionToWebProcess;
    6059class NetworkLoad;
     
    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;
  • trunk/Source/WebKit/NetworkProcess/FileAPI/NetworkBlobRegistry.cpp

    r241008 r248593  
    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;
    183169}
    184 
    185 }
  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.cpp

    r247905 r248593  
    302302    m_networkProcess->webProcessWasDisconnected(connection);
    303303
    304     m_networkProcess->networkBlobRegistry().connectionToWebProcessDidClose(*this);
    305304    m_networkProcess->removeNetworkConnectionToWebProcess(*this);
    306305
     
    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
     
    569574}
    570575
    571 void NetworkConnectionToWebProcess::registerFileBlobURL(const URL& url, const String& path, SandboxExtension::Handle&& extensionHandle, const String& contentType)
    572 {
    573     m_networkProcess->networkBlobRegistry().registerFileBlobURL(*this, url, path, SandboxExtension::create(WTFMove(extensionHandle)), contentType);
    574 }
    575 
    576 void NetworkConnectionToWebProcess::registerBlobURL(const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
    577 {
    578     m_networkProcess->networkBlobRegistry().registerBlobURL(*this, url, WTFMove(blobParts), contentType);
    579 }
    580 
    581 void NetworkConnectionToWebProcess::registerBlobURLFromURL(const URL& url, const URL& srcURL, bool shouldBypassConnectionCheck)
    582 {
    583     m_networkProcess->networkBlobRegistry().registerBlobURL(*this, url, srcURL, shouldBypassConnectionCheck);
    584 }
    585 
    586 void NetworkConnectionToWebProcess::registerBlobURLOptionallyFileBacked(const URL& url, const URL& srcURL, const String& fileBackedPath, const String& contentType)
    587 {
    588     m_networkProcess->networkBlobRegistry().registerBlobURLOptionallyFileBacked(*this, url, srcURL, fileBackedPath, contentType);
    589 }
    590 
    591 void NetworkConnectionToWebProcess::registerBlobURLForSlice(const URL& url, const URL& srcURL, int64_t start, int64_t end)
    592 {
    593     m_networkProcess->networkBlobRegistry().registerBlobURLForSlice(*this, url, srcURL, start, end);
    594 }
    595 
    596 void NetworkConnectionToWebProcess::unregisterBlobURL(const URL& url)
    597 {
    598     m_networkProcess->networkBlobRegistry().unregisterBlobURL(*this, url);
     576void NetworkConnectionToWebProcess::registerFileBlobURL(PAL::SessionID sessionID, const URL& url, const String& path, SandboxExtension::Handle&& extensionHandle, const String& contentType)
     577{
     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);
     583}
     584
     585void NetworkConnectionToWebProcess::registerBlobURL(PAL::SessionID sessionID, const URL& url, Vector<BlobPart>&& blobParts, const String& contentType)
     586{
     587    auto* session = networkProcess().networkSession(sessionID);
     588    if (!session)
     589        return;
     590
     591    session->blobRegistry().registerBlobURL(url, WTFMove(blobParts), contentType);
     592}
     593
     594void NetworkConnectionToWebProcess::registerBlobURLFromURL(PAL::SessionID sessionID, const URL& url, const URL& srcURL)
     595{
     596    auto* session = networkProcess().networkSession(sessionID);
     597    if (!session)
     598        return;
     599
     600    session->blobRegistry().registerBlobURL(url, srcURL);
     601}
     602
     603void NetworkConnectionToWebProcess::registerBlobURLOptionallyFileBacked(PAL::SessionID sessionID, const URL& url, const URL& srcURL, const String& fileBackedPath, const String& contentType)
     604{
     605    auto* session = networkProcess().networkSession(sessionID);
     606    if (!session)
     607        return;
     608
     609    session->blobRegistry().registerBlobURLOptionallyFileBacked(url, srcURL, BlobDataFileReferenceWithSandboxExtension::create(fileBackedPath, nullptr), contentType);
     610}
     611
     612void NetworkConnectionToWebProcess::registerBlobURLForSlice(PAL::SessionID sessionID, const URL& url, const URL& srcURL, int64_t start, int64_t end)
     613{
     614    auto* session = networkProcess().networkSession(sessionID);
     615    if (!session)
     616        return;
     617
     618    session->blobRegistry().registerBlobURLForSlice(url, srcURL, start, end);
     619}
     620
     621void NetworkConnectionToWebProcess::unregisterBlobURL(PAL::SessionID sessionID, const URL& url)
     622{
     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));
    604 }
    605 
    606 void NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&&)>&& completionHandler)
    607 {
     632    auto* blobRegistry = networkProcess().blobRegistry(*this);
     633    if (!blobRegistry)
     634        return;
     635
     636    completionHandler(blobRegistry->blobSize(url));
     637}
     638
     639void NetworkConnectionToWebProcess::writeBlobsToTemporaryFiles(PAL::SessionID sessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&&)>&& completionHandler)
     640{
     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    });
    620 }
    621 
    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();
    630657}
    631658
  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.h

    r247822 r248593  
    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
     
    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);
  • trunk/Source/WebKit/NetworkProcess/NetworkConnectionToWebProcess.messages.in

    r247822 r248593  
    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)
  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.cpp

    r248526 r248593  
    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)
  • trunk/Source/WebKit/NetworkProcess/NetworkProcess.h

    r248526 r248593  
    3030#include "DownloadManager.h"
    3131#include "LocalStorageDatabaseTracker.h"
    32 #include "NetworkBlobRegistry.h"
    3332#include "NetworkContentRuleListManager.h"
    3433#include "NetworkHTTPSUpgradeChecker.h"
     
    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&&);
     
    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)
  • trunk/Source/WebKit/NetworkProcess/NetworkProcessPlatformStrategies.cpp

    r241008 r248593  
    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;
  • trunk/Source/WebKit/NetworkProcess/NetworkResourceLoader.cpp

    r248540 r248593  
    302302        parameters.storedCredentialsPolicy = m_networkLoadChecker->storedCredentialsPolicy();
    303303
    304     if (request.url().protocolIsBlob())
    305         parameters.blobFileReferences = m_connection->filesInBlob(originalRequest().url());
    306 
    307304    auto* networkSession = m_connection->networkProcess().networkSession(parameters.sessionID);
    308305    if (!networkSession && parameters.sessionID.isEphemeral()) {
     
    318315    }
    319316
     317    if (request.url().protocolIsBlob())
     318        parameters.blobFileReferences = networkSession->blobRegistry().filesInBlob(originalRequest().url());
     319
    320320    parameters.request = WTFMove(request);
    321     m_networkLoad = std::make_unique<NetworkLoad>(*this, &m_connection->blobRegistry(), WTFMove(parameters), *networkSession);
     321    m_networkLoad = std::make_unique<NetworkLoad>(*this, &networkSession->blobRegistry(), WTFMove(parameters), *networkSession);
    322322
    323323    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());
  • trunk/Source/WebKit/NetworkProcess/NetworkSession.h

    r248144 r248593  
    3030#include "WebResourceLoadStatisticsStore.h"
    3131#include <WebCore/AdClickAttribution.h>
     32#include <WebCore/BlobRegistryImpl.h>
    3233#include <WebCore/RegistrableDomain.h>
    3334#include <pal/SessionID.h>
     
    115116    virtual void addWebSocketTask(WebSocketTask&) { }
    116117
     118    WebCore::BlobRegistryImpl& blobRegistry() { return m_blobRegistry; }
     119
    117120protected:
    118121    NetworkSession(NetworkProcess&, const NetworkSessionCreationParameters&);
     
    144147#endif
    145148    RefPtr<NetworkCache::Cache> m_cache;
     149    WebCore::BlobRegistryImpl m_blobRegistry;
    146150};
    147151
  • trunk/Source/WebKit/NetworkProcess/soup/NetworkDataTaskSoup.cpp

    r247856 r248593  
    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);
  • trunk/Source/WebKit/NetworkProcess/soup/NetworkSessionSoup.cpp

    r248010 r248593  
    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);
  • trunk/Source/WebKit/Sources.txt

    r248422 r248593  
    5757NetworkProcess/Downloads/DownloadMonitor.cpp
    5858NetworkProcess/Downloads/PendingDownload.cpp
    59 
    60 NetworkProcess/FileAPI/NetworkBlobRegistry.cpp
    6159
    6260NetworkProcess/IndexedDB/WebIDBConnectionToClient.cpp
  • trunk/Source/WebKit/WebKit.xcodeproj/project.pbxproj

    r248592 r248593  
    13181318                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 */; };
    13191319                A1046EA12079263100F0C5D8 /* WKPDFView.h in Headers */ = {isa = PBXBuildFile; fileRef = A1046E9F2079263100F0C5D8 /* WKPDFView.h */; };
    1320                 A105D0D1212734B20034F6C7 /* NetworkBlobRegistry.h in Headers */ = {isa = PBXBuildFile; fileRef = A105D0D0212734B10034F6C7 /* NetworkBlobRegistry.h */; };
    13211320                A115DC72191D82DA00DA8072 /* _WKWebViewPrintFormatter.h in Headers */ = {isa = PBXBuildFile; fileRef = A115DC6E191D82AB00DA8072 /* _WKWebViewPrintFormatter.h */; settings = {ATTRIBUTES = (Private, ); }; };
    13221321                A118A9EF1907AD6F00F7C92B /* QuickLookDocumentData.h in Headers */ = {isa = PBXBuildFile; fileRef = A118A9ED1907AD6F00F7C92B /* QuickLookDocumentData.h */; };
     
    39883987                A1046E9F2079263100F0C5D8 /* WKPDFView.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = WKPDFView.h; path = ios/WKPDFView.h; sourceTree = "<group>"; };
    39893988                A1046EA02079263100F0C5D8 /* WKPDFView.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; name = WKPDFView.mm; path = ios/WKPDFView.mm; sourceTree = "<group>"; };
    3990                 A105D0D0212734B10034F6C7 /* NetworkBlobRegistry.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NetworkBlobRegistry.h; sourceTree = "<group>"; };
    39913989                A115DC6D191D82AB00DA8072 /* _WKWebViewPrintFormatter.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = _WKWebViewPrintFormatter.mm; sourceTree = "<group>"; };
    39923990                A115DC6E191D82AB00DA8072 /* _WKWebViewPrintFormatter.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = _WKWebViewPrintFormatter.h; sourceTree = "<group>"; };
     
    46224620                E170876916D6CA6900F99226 /* BlobRegistryProxy.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = BlobRegistryProxy.cpp; path = WebProcess/FileAPI/BlobRegistryProxy.cpp; sourceTree = "<group>"; };
    46234621                E170876A16D6CA6900F99226 /* BlobRegistryProxy.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = BlobRegistryProxy.h; path = WebProcess/FileAPI/BlobRegistryProxy.h; sourceTree = "<group>"; };
    4624                 E1798C7716E6818800240139 /* NetworkBlobRegistry.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NetworkBlobRegistry.cpp; sourceTree = "<group>"; };
    46254622                E17AE2C116B9C139001C42F1 /* com.apple.WebKit.NetworkProcess.sb.in */ = {isa = PBXFileReference; lastKnownFileType = text; path = com.apple.WebKit.NetworkProcess.sb.in; sourceTree = "<group>"; };
    46264623                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; };
     
    66686665                                5C1426F11C23F81700D41183 /* Downloads */,
    66696666                                BC82837C16B45DA500A278FE /* EntryPoint */,
    6670                                 E1798C7616E6815500240139 /* FileAPI */,
    66716667                                939288E021404DF000EBBA33 /* IndexedDB */,
    66726668                                2DA944BB188511DD00ED86DB /* ios */,
     
    90269022                        );
    90279023                        name = FileAPI;
    9028                         sourceTree = "<group>";
    9029                 };
    9030                 E1798C7616E6815500240139 /* FileAPI */ = {
    9031                         isa = PBXGroup;
    9032                         children = (
    9033                                 E1798C7716E6818800240139 /* NetworkBlobRegistry.cpp */,
    9034                                 A105D0D0212734B10034F6C7 /* NetworkBlobRegistry.h */,
    9035                         );
    9036                         path = FileAPI;
    90379024                        sourceTree = "<group>";
    90389025                };
     
    94849471                                1AA5889211EE70400061B882 /* NetscapePluginStream.h in Headers */,
    94859472                                535BCB922069C49C00CCCE02 /* NetworkActivityTracker.h in Headers */,
    9486                                 A105D0D1212734B20034F6C7 /* NetworkBlobRegistry.h in Headers */,
    94879473                                E4436ECC1A0D040B00EAD204 /* NetworkCache.h in Headers */,
    94889474                                E49D40D71AD3FB170066B7B9 /* NetworkCacheBlobStorage.h in Headers */,
  • trunk/Source/WebKit/WebProcess/FileAPI/BlobRegistryProxy.cpp

    r238771 r248593  
    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;
     
    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
     
    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
  • trunk/Source/WebKit/WebProcess/FileAPI/BlobRegistryProxy.h

    r238771 r248593  
    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
  • trunk/Source/WebKit/WebProcess/Network/NetworkProcessConnection.cpp

    r246939 r248593  
    212212}
    213213
    214 void NetworkProcessConnection::writeBlobsToTemporaryFiles(const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&& completionHandler)
    215 {
    216     WebProcess::singleton().ensureNetworkProcessConnection().connection().sendWithAsyncReply(Messages::NetworkConnectionToWebProcess::WriteBlobsToTemporaryFiles(blobURLs), WTFMove(completionHandler));
     214void NetworkProcessConnection::writeBlobsToTemporaryFiles(PAL::SessionID sessionID, const Vector<String>& blobURLs, CompletionHandler<void(Vector<String>&& filePaths)>&& completionHandler)
     215{
     216    WebProcess::singleton().ensureNetworkProcessConnection().connection().sendWithAsyncReply(Messages::NetworkConnectionToWebProcess::WriteBlobsToTemporaryFiles(sessionID, blobURLs), WTFMove(completionHandler));
    217217}
    218218
  • trunk/Source/WebKit/WebProcess/Network/NetworkProcessConnection.h

    r245913 r248593  
    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)
  • trunk/Source/WebKitLegacy/mac/ChangeLog

    r248533 r248593  
     12019-08-13  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 Alex Christensen.
     7
     8        * WebCoreSupport/WebPlatformStrategies.mm:
     9        (WebPlatformStrategies::createBlobRegistry):
     10        Ignore sessionID parameter for WK1.
     11
    1122019-08-12  Chris Dumez  <cdumez@apple.com>
    213
  • trunk/Source/WebKitLegacy/mac/WebCoreSupport/WebPlatformStrategies.mm

    r241749 r248593  
    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
  • trunk/Source/WebKitLegacy/win/ChangeLog

    r248526 r248593  
     12019-08-13  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 Alex Christensen.
     8
     9        * WebCoreSupport/WebPlatformStrategies.cpp:
     10        (WebPlatformStrategies::createBlobRegistry):
     11
    1122019-08-12  Youenn Fablet  <youenn@apple.com>
    213
  • trunk/Source/WebKitLegacy/win/WebCoreSupport/WebPlatformStrategies.cpp

    r240014 r248593  
    2828#include "WebFrameNetworkingContext.h"
    2929#include "WebResourceLoadScheduler.h"
     30#include <WebCore/BlobRegistry.h>
    3031#include <WebCore/BlobRegistryImpl.h>
    3132#include <WebCore/FrameLoader.h>
     
    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}
Note: See TracChangeset for help on using the changeset viewer.