Attachment 369439 Details for Bug 197463 – Patch

[patch] Patch

bug-197463-20190508155107.patch (text/plain), 21.84 KB, created by youenn fablet on 2019-05-08 15:51:08 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: youenn fablet

Created: 2019-05-08 15:51:08 PDT

Size: 21.84 KB

patch

obsolete

>Subversion Revision: 245009
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index 7f668cb8badd308d6758935973cfa97dd978195d..e0f85bc83290ff9d6f468c791eb3f54d27029699 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,46 @@
>+2019-05-08  Youenn Fablet  <youenn@apple.com>
>+
>+        Reuse existing WebPageProxy quota handler for NetworkProcessProxy quota requests
>+        https://bugs.webkit.org/show_bug.cgi?id=197463
>+        <rdar://problem/47403621>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add a getter to know whether websitedatastore client implements the quota delegate.
>+        If not, find the most visible page that is the same origin as the quota request
>+        and reuse the existing exceededDatabasQuota delegate.
>+        This approach allows to call the delegate even if the quota request comes from a service worker.
>+        If no such page is found, the quota will not be increased.
>+
>+        Refactoring to make sure we are calling the delegate once a previous call to that delegate is completed.
>+        Manually tested.
>+
>+        * NetworkProcess/NetworkProcess.cpp:
>+        (WebKit::NetworkProcess::clearStorageQuota):
>+        (WebKit::NetworkProcess::storageQuotaManager):
>+        * UIProcess/API/Cocoa/WKWebsiteDataStore.mm:
>+        * UIProcess/Network/NetworkProcessProxy.cpp:
>+        (WebKit::NetworkProcessProxy::requestStorageSpace):
>+        * UIProcess/WebPageProxy.cpp:
>+        (WebKit::StorageRequests::add):
>+        (WebKit::StorageRequests::processNext):
>+        (WebKit::StorageRequests::areBeingProcessed const):
>+        (WebKit::StorageRequests::setAreBeingProcessed):
>+        (WebKit::StorageRequests::StorageRequests):
>+        (WebKit::StorageRequests::~StorageRequests):
>+        (WebKit::StorageRequests::singleton):
>+        (WebKit::WebPageProxy::forMostVisibleWebPageIfAny):
>+        (WebKit::WebPageProxy::didChangeMainDocument):
>+        (WebKit::WebPageProxy::exceededDatabaseQuota):
>+        (WebKit::WebPageProxy::requestStorageSpace):
>+        (WebKit::WebPageProxy::makeStorageSpaceRequest):
>+        * UIProcess/WebPageProxy.h:
>+        * UIProcess/WebProcessProxy.cpp:
>+        (WebKit::WebProcessProxy::forWebPages):
>+        * UIProcess/WebProcessProxy.h:
>+        * UIProcess/WebsiteData/WebsiteDataStoreClient.h:
>+        (WebKit::WebsiteDataStoreClient::implementsRequestStorageSpaceHandler const):
>+
> 2019-05-06  Youenn Fablet  <youenn@apple.com>
> 
>         A service worker process should app nap when all its clients app nap
>diff --git a/Source/WebKit/NetworkProcess/NetworkProcess.cpp b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>index a60b2c55bf1e3483b9d33a532f881c63a83eabaf..20fb824a10fbdc70f6961003a224eaef4455cd28 100644
>--- a/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>+++ b/Source/WebKit/NetworkProcess/NetworkProcess.cpp
>@@ -1525,7 +1525,7 @@ void NetworkProcess::clearStorageQuota(PAL::SessionID sessionID)
> 
>     auto& managers = iterator->value;
>     for (auto& manager : managers.managersPerOrigin())
>-        manager.value->resetQuota(managers.defaultQuota(manager.key));
>+        manager.value->resetQuota(4 * KB);
> }
> 
> #if ENABLE(RESOURCE_LOAD_STATISTICS)
>@@ -2500,8 +2500,8 @@ StorageQuotaManager& NetworkProcess::storageQuotaManager(PAL::SessionID sessionI
>     auto& storageQuotaManagers = m_storageQuotaManagers.ensure(sessionID, [] {
>         return StorageQuotaManagers { };
>     }).iterator->value;
>-    return *storageQuotaManagers.managersPerOrigin().ensure(origin, [this, &storageQuotaManagers, sessionID, &origin] {
>-        auto manager = std::make_unique<StorageQuotaManager>(storageQuotaManagers.defaultQuota(origin), [this, sessionID, origin](uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, auto callback) {
>+    return *storageQuotaManagers.managersPerOrigin().ensure(origin, [this, sessionID, &origin] {
>+        auto manager = std::make_unique<StorageQuotaManager>(4 * KB, [this, sessionID, origin](uint64_t quota, uint64_t currentSpace, uint64_t spaceIncrease, auto callback) {
>             this->requestStorageSpace(sessionID, origin, quota, currentSpace, spaceIncrease, WTFMove(callback));
>         });
>         initializeQuotaUsers(*manager, sessionID, origin);
>diff --git a/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm b/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm
>index 7dd4119c97b193b2843655e523ed8b7dc7e592b3..a7ce26e73106e26d255fccbc43134fa8b2573995 100644
>--- a/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm
>+++ b/Source/WebKit/UIProcess/API/Cocoa/WKWebsiteDataStore.mm
>@@ -43,7 +43,7 @@
> #import <wtf/URL.h>
> #import <wtf/WeakObjCPtr.h>
> 
>-class WebsiteDataStoreClient : public WebKit::WebsiteDataStoreClient {
>+class WebsiteDataStoreClient final : public WebKit::WebsiteDataStoreClient {
> public:
>     explicit WebsiteDataStoreClient(id <_WKWebsiteDataStoreDelegate> delegate)
>         : m_delegate(delegate)
>@@ -52,6 +52,7 @@ public:
>     }
> 
> private:
>+    bool implementsRequestStorageSpaceHandler() const final { return m_hasRequestStorageSpaceSelector && !!m_delegate; }
>     void requestStorageSpace(const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& frameOrigin, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(Optional<uint64_t>)>&& completionHandler) final
>     {
>         if (!m_hasRequestStorageSpaceSelector || !m_delegate) {
>diff --git a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>index c344d16382735b0b683c696f9b662671071d8464..68911713102e23db67a947645b6ca7cf966a871b 100644
>--- a/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp
>@@ -1197,7 +1197,7 @@ void NetworkProcessProxy::establishWorkerContextConnectionToNetworkProcessForExp
> }
> #endif
> 
>-void NetworkProcessProxy::requestStorageSpace(PAL::SessionID sessionID, const WebCore::ClientOrigin& origin, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(Optional<uint64_t> quota)>&& completionHandler)
>+void NetworkProcessProxy::requestStorageSpace(PAL::SessionID sessionID, const WebCore::ClientOrigin& origin, uint64_t currentQuota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(Optional<uint64_t> quota)>&& completionHandler)
> {
>     auto* store = websiteDataStoreFromSessionID(sessionID);
> 
>@@ -1206,7 +1206,26 @@ void NetworkProcessProxy::requestStorageSpace(PAL::SessionID sessionID, const We
>         return;
>     }
> 
>-    store->client().requestStorageSpace(origin.topOrigin, origin.clientOrigin, quota, currentSize, spaceRequired, WTFMove(completionHandler));
>+    if (store->client().implementsRequestStorageSpaceHandler()) {
>+        store->client().requestStorageSpace(origin.topOrigin, origin.clientOrigin, currentQuota, currentSize, spaceRequired, WTFMove(completionHandler));
>+        return;
>+    }
>+
>+    if (origin.topOrigin != origin.clientOrigin) {
>+        completionHandler({ });
>+        return;
>+    }
>+
>+    WebPageProxy::forMostVisibleWebPageIfAny(sessionID, origin.topOrigin, [completionHandler = WTFMove(completionHandler), origin, currentQuota, currentSize, spaceRequired](auto* page) mutable {
>+        if (!page) {
>+            completionHandler({ });
>+            return;
>+        }
>+        String name = makeString(FileSystem::encodeForFileName(origin.topOrigin.host), " content");
>+        page->requestStorageSpace(page->mainFrame()->frameID(), origin.topOrigin.databaseIdentifier(), name, name, currentQuota, currentSize, currentSize, spaceRequired, [completionHandler = WTFMove(completionHandler)](auto quota) mutable {
>+            completionHandler(quota);
>+        });
>+    });
> }
> 
> void NetworkProcessProxy::takeUploadAssertion()
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.cpp b/Source/WebKit/UIProcess/WebPageProxy.cpp
>index 4e1aef9a6b4452f31659088b1e7cc94919ac6e94..40c54d071a15390fa7d55d1a45b4c00f6f9d3f12 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebPageProxy.cpp
>@@ -262,76 +262,37 @@ using namespace WebCore;
> 
> DEFINE_DEBUG_ONLY_GLOBAL(WTF::RefCountedLeakCounter, webPageProxyCounter, ("WebPageProxy"));
> 
>-class ExceededDatabaseQuotaRecords {
>-    WTF_MAKE_NONCOPYABLE(ExceededDatabaseQuotaRecords); WTF_MAKE_FAST_ALLOCATED;
>-    friend NeverDestroyed<ExceededDatabaseQuotaRecords>;
>+class StorageRequests {
>+    WTF_MAKE_NONCOPYABLE(StorageRequests); WTF_MAKE_FAST_ALLOCATED;
>+    friend NeverDestroyed<StorageRequests>;
> public:
>-    struct Record {
>-        uint64_t frameID;
>-        String originIdentifier;
>-        String databaseName;
>-        String displayName;
>-        uint64_t currentQuota;
>-        uint64_t currentOriginUsage;
>-        uint64_t currentDatabaseUsage;
>-        uint64_t expectedUsage;
>-        Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply reply;
>-    };
>-
>-    static ExceededDatabaseQuotaRecords& singleton();
>+    static StorageRequests& singleton();
> 
>-    std::unique_ptr<Record> createRecord(uint64_t frameID, String originIdentifier,
>-        String databaseName, String displayName, uint64_t currentQuota,
>-        uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, 
>-        Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply&&);
>+    void add(WTF::CompletionHandler<void()>&& completionHandler) { m_requests.append(WTFMove(completionHandler)); }
>+    void processNext()
>+    {
>+        if (m_requests.isEmpty()) {
>+            m_areBeingProcessing = false;
>+            return;
>+        }
>+        m_requests.takeFirst()();
>+    }
> 
>-    void add(std::unique_ptr<Record>);
>-    bool areBeingProcessed() const { return !!m_currentRecord; }
>-    Record* next();
>+    bool areBeingProcessed() const { return m_areBeingProcessing; }
>+    void setAreBeingProcessed(bool areBeingProcessing) { m_areBeingProcessing = areBeingProcessing; }
> 
> private:
>-    ExceededDatabaseQuotaRecords() { }
>-    ~ExceededDatabaseQuotaRecords() { }
>+    StorageRequests() { }
>+    ~StorageRequests() { }
> 
>-    Deque<std::unique_ptr<Record>> m_records;
>-    std::unique_ptr<Record> m_currentRecord;
>+    Deque<WTF::CompletionHandler<void()>> m_requests;
>+    bool m_areBeingProcessing { false };
> };
> 
>-ExceededDatabaseQuotaRecords& ExceededDatabaseQuotaRecords::singleton()
>-{
>-    static NeverDestroyed<ExceededDatabaseQuotaRecords> records;
>-    return records;
>-}
>-
>-std::unique_ptr<ExceededDatabaseQuotaRecords::Record> ExceededDatabaseQuotaRecords::createRecord(
>-    uint64_t frameID, String originIdentifier, String databaseName, String displayName,
>-    uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage,
>-    uint64_t expectedUsage, Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply&& reply)
>-{
>-    auto record = std::make_unique<Record>();
>-    record->frameID = frameID;
>-    record->originIdentifier = originIdentifier;
>-    record->databaseName = databaseName;
>-    record->displayName = displayName;
>-    record->currentQuota = currentQuota;
>-    record->currentOriginUsage = currentOriginUsage;
>-    record->currentDatabaseUsage = currentDatabaseUsage;
>-    record->expectedUsage = expectedUsage;
>-    record->reply = WTFMove(reply);
>-    return record;
>-}
>-
>-void ExceededDatabaseQuotaRecords::add(std::unique_ptr<ExceededDatabaseQuotaRecords::Record> record)
>-{
>-    m_records.append(WTFMove(record));
>-}
>-
>-ExceededDatabaseQuotaRecords::Record* ExceededDatabaseQuotaRecords::next()
>+StorageRequests& StorageRequests::singleton()
> {
>-    m_currentRecord = nullptr;
>-    if (!m_records.isEmpty())
>-        m_currentRecord = m_records.takeFirst();
>-    return m_currentRecord.get();
>+    static NeverDestroyed<StorageRequests> requests;
>+    return requests;
> }
> 
> #if !LOG_DISABLED
>@@ -393,6 +354,25 @@ private:
>     WeakPtr<PageClient> m_pageClient;
> };
> 
>+void WebPageProxy::forMostVisibleWebPageIfAny(PAL::SessionID sessionID, const SecurityOriginData& origin, CompletionHandler<void(WebPageProxy*)>&& completionHandler)
>+{
>+    // FIXME: If not finding right away a visible page, we might want to try again for a given period of time when there is a change of visibility.
>+    WebPageProxy* selectedPage = nullptr;
>+    WebProcessProxy::forWebPages(sessionID, origin, [&](auto& page) {
>+        if (!page.mainFrame())
>+            return;
>+        if (page.isViewVisible() && (!selectedPage || !selectedPage->isViewVisible())) {
>+            selectedPage = &page;
>+            return;
>+        }
>+        if (page.isViewFocused() && (!selectedPage || !selectedPage->isViewFocused())) {
>+            selectedPage = &page;
>+            return;
>+        }
>+    });
>+    completionHandler(selectedPage);
>+}
>+
> Ref<WebPageProxy> WebPageProxy::create(PageClient& pageClient, WebProcessProxy& process, uint64_t pageID, Ref<API::PageConfiguration>&& configuration)
> {
>     return adoptRef(*new WebPageProxy(pageClient, process, pageID, WTFMove(configuration)));
>@@ -4386,6 +4366,7 @@ void WebPageProxy::didChangeMainDocument(uint64_t frameID)
> #else
>     UNUSED_PARAM(frameID);
> #endif
>+    m_isQuotaIncreaseDenied = false;
> }
> 
> void WebPageProxy::viewIsBecomingVisible()
>@@ -7230,24 +7211,48 @@ void WebPageProxy::didReceiveAuthenticationChallengeProxy(uint64_t, Ref<Authenti
> 
> void WebPageProxy::exceededDatabaseQuota(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, Messages::WebPageProxy::ExceededDatabaseQuota::DelayedReply&& reply)
> {
>-    ExceededDatabaseQuotaRecords& records = ExceededDatabaseQuotaRecords::singleton();
>-    std::unique_ptr<ExceededDatabaseQuotaRecords::Record> newRecord = records.createRecord(frameID,
>-        originIdentifier, databaseName, displayName, currentQuota, currentOriginUsage,
>-        currentDatabaseUsage, expectedUsage, WTFMove(reply));
>-    records.add(WTFMove(newRecord));
>+    requestStorageSpace(frameID, originIdentifier, databaseName, displayName, currentQuota, currentOriginUsage, currentDatabaseUsage, expectedUsage, [reply = WTFMove(reply)](auto quota) mutable {
>+        reply(quota);
>+    });
>+}
>+
>+void WebPageProxy::requestStorageSpace(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, CompletionHandler<void(uint64_t)>&& completionHandler)
>+{
>+    auto requestCompletionHandler = [this, protectedThis = makeRef(*this), completionHandler = WTFMove(completionHandler), currentQuota](auto quota) mutable {
>+        completionHandler(quota);
>+        m_isQuotaIncreaseDenied =  quota <= currentQuota;
>+        StorageRequests::singleton().processNext();
>+    };
>+
>+    auto& requests = StorageRequests::singleton();
>+    if (requests.areBeingProcessed()) {
>+        requests.add([this, frameID, originIdentifier, databaseName, displayName, currentQuota, currentOriginUsage, currentDatabaseUsage, expectedUsage, requestCompletionHandler = WTFMove(requestCompletionHandler)]() mutable {
>+            this->makeStorageSpaceRequest(frameID, originIdentifier, databaseName, displayName, currentQuota, currentOriginUsage, currentDatabaseUsage, expectedUsage, WTFMove(requestCompletionHandler));
>+        });
>+        return;
>+    }
>+    requests.setAreBeingProcessed(true);
>+    makeStorageSpaceRequest(frameID, originIdentifier, databaseName, displayName, currentQuota, currentOriginUsage, currentDatabaseUsage, expectedUsage, WTFMove(requestCompletionHandler));
>+}
> 
>-    if (records.areBeingProcessed())
>+void WebPageProxy::makeStorageSpaceRequest(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, CompletionHandler<void(uint64_t)>&& completionHandler)
>+{
>+    if (m_isQuotaIncreaseDenied) {
>+        completionHandler(currentQuota);
>         return;
>+    }
> 
>-    ExceededDatabaseQuotaRecords::Record* record = records.next();
>-    while (record) {
>-        WebFrameProxy* frame = m_process->webFrame(record->frameID);
>-        MESSAGE_CHECK(m_process, frame);
>+    WebFrameProxy* frame = m_process->webFrame(frameID);
>+    MESSAGE_CHECK(m_process, frame);
> 
>-        auto origin = API::SecurityOrigin::create(SecurityOriginData::fromDatabaseIdentifier(record->originIdentifier)->securityOrigin());
>-        m_uiClient->exceededDatabaseQuota(this, frame, origin.ptr(), record->databaseName, record->displayName, record->currentQuota, record->currentOriginUsage, record->currentDatabaseUsage, record->expectedUsage, WTFMove(record->reply));
>-        record = records.next();
>+    auto originData = SecurityOriginData::fromDatabaseIdentifier(originIdentifier);
>+    if (originData != SecurityOriginData::fromURL(URL { { }, currentURL() })) {
>+        completionHandler(currentQuota);
>+        return;
>     }
>+
>+    auto origin = API::SecurityOrigin::create(originData->securityOrigin());
>+    m_uiClient->exceededDatabaseQuota(this, frame, origin.ptr(), databaseName, displayName, currentQuota, currentOriginUsage, currentDatabaseUsage, expectedUsage, WTFMove(completionHandler));
> }
> 
> void WebPageProxy::reachedApplicationCacheOriginQuota(const String& originIdentifier, uint64_t currentQuota, uint64_t totalBytesNeeded, Messages::WebPageProxy::ReachedApplicationCacheOriginQuota::DelayedReply&& reply)
>diff --git a/Source/WebKit/UIProcess/WebPageProxy.h b/Source/WebKit/UIProcess/WebPageProxy.h
>index 8720eebd7fb7ccf0b37388ab8bf2fdfed7b1c19b..f91483a1ddec66754a0fd45666b250eca9fa676a 100644
>--- a/Source/WebKit/UIProcess/WebPageProxy.h
>+++ b/Source/WebKit/UIProcess/WebPageProxy.h
>@@ -383,6 +383,8 @@ public:
>     static Ref<WebPageProxy> create(PageClient&, WebProcessProxy&, uint64_t pageID, Ref<API::PageConfiguration>&&);
>     virtual ~WebPageProxy();
> 
>+    static void forMostVisibleWebPageIfAny(PAL::SessionID, const WebCore::SecurityOriginData&, CompletionHandler<void(WebPageProxy*)>&&);
>+
>     const API::PageConfiguration& configuration() const;
> 
>     uint64_t pageID() const { return m_pageID; }
>@@ -1537,6 +1539,8 @@ WEBPAGEPROXY_LOADOPTIMIZER_ADDITIONS_1
>     void didReceiveMessage(IPC::Connection&, IPC::Decoder&) override;
>     void didReceiveSyncMessage(IPC::Connection&, IPC::Decoder&, std::unique_ptr<IPC::Encoder>&) override;
> 
>+    void requestStorageSpace(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, WTF::CompletionHandler<void(uint64_t)>&&);
>+
> private:
>     WebPageProxy(PageClient&, WebProcessProxy&, uint64_t pageID, Ref<API::PageConfiguration>&&);
>     void platformInitialize();
>@@ -2073,6 +2077,9 @@ private:
>     static bool isInHardwareKeyboardMode();
> #endif
> 
>+    void makeStorageSpaceRequest(uint64_t frameID, const String& originIdentifier, const String& databaseName, const String& displayName, uint64_t currentQuota, uint64_t currentOriginUsage, uint64_t currentDatabaseUsage, uint64_t expectedUsage, WTF::CompletionHandler<void(uint64_t)>&&);
>+
>+
>     WeakPtr<PageClient> m_pageClient;
>     Ref<API::PageConfiguration> m_configuration;
> 
>@@ -2502,6 +2509,7 @@ WEBPAGEPROXY_LOADOPTIMIZER_ADDITIONS_2
>     };
>     Optional<SpeechSynthesisData> m_speechSynthesisData;
> #endif
>+    bool m_isQuotaIncreaseDenied { false };
> };
> 
> } // namespace WebKit
>diff --git a/Source/WebKit/UIProcess/WebProcessProxy.cpp b/Source/WebKit/UIProcess/WebProcessProxy.cpp
>index 41d300440c19daa1195aad39dcc23be06cbd6d38..8bd2a04c469f1a8c7a0cdec8b26c0f1f89beee62 100644
>--- a/Source/WebKit/UIProcess/WebProcessProxy.cpp
>+++ b/Source/WebKit/UIProcess/WebProcessProxy.cpp
>@@ -122,6 +122,15 @@ static WebProcessProxy::WebPageProxyMap& globalPageMap()
>     return pageMap;
> }
> 
>+void WebProcessProxy::forWebPages(PAL::SessionID sessionID, const SecurityOriginData& origin, const WTF::Function<void(WebPageProxy&)>& callback)
>+{
>+    for (auto* page : globalPageMap().values()) {
>+        if (page->sessionID() != sessionID || SecurityOriginData::fromURL(URL { { }, page->currentURL() }) != origin)
>+            continue;
>+        callback(*page);
>+    }
>+}
>+
> Ref<WebProcessProxy> WebProcessProxy::create(WebProcessPool& processPool, WebsiteDataStore* websiteDataStore, IsPrewarmed isPrewarmed, ShouldLaunchProcess shouldLaunchProcess)
> {
>     auto proxy = adoptRef(*new WebProcessProxy(processPool, websiteDataStore, isPrewarmed));
>diff --git a/Source/WebKit/UIProcess/WebProcessProxy.h b/Source/WebKit/UIProcess/WebProcessProxy.h
>index 1284aea5187c1f884acf255ca030ed93cadeff85..a07195b8bab35eceeec5d62b6b240cad98ab6ad5 100644
>--- a/Source/WebKit/UIProcess/WebProcessProxy.h
>+++ b/Source/WebKit/UIProcess/WebProcessProxy.h
>@@ -110,6 +110,8 @@ public:
>     static Ref<WebProcessProxy> create(WebProcessPool&, WebsiteDataStore*, IsPrewarmed, ShouldLaunchProcess = ShouldLaunchProcess::Yes);
>     ~WebProcessProxy();
> 
>+    static void forWebPages(PAL::SessionID, const WebCore::SecurityOriginData&, const WTF::Function<void(WebPageProxy&)>&);
>+
>     WebConnection* webConnection() const { return m_webConnection.get(); }
> 
>     unsigned suspendedPageCount() const { return m_suspendedPageCount; }
>diff --git a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreClient.h b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreClient.h
>index e9fcf00153995dc1cce135f8c092e92e66dbff3a..1d320aa65e0076ed44d8c8e05b1281fc9f94771e 100644
>--- a/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreClient.h
>+++ b/Source/WebKit/UIProcess/WebsiteData/WebsiteDataStoreClient.h
>@@ -37,6 +37,7 @@ class WebsiteDataStoreClient {
> public:
>     virtual ~WebsiteDataStoreClient() { }
> 
>+    virtual bool implementsRequestStorageSpaceHandler() const { return false; }
>     virtual void requestStorageSpace(const WebCore::SecurityOriginData& topOrigin, const WebCore::SecurityOriginData& frameOrigin, uint64_t quota, uint64_t currentSize, uint64_t spaceRequired, CompletionHandler<void(Optional<uint64_t>)>&& completionHandler)
>     {
>         completionHandler({ });

Flags:

ews-watchlist: commit-queue-

Actions: View | Formatted Diff | Diff

Attachments on bug 197463: 368677 | 369439 | 369449 | 369591 | 369883 | 369897 | 369902 | 369916 | 369960