⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 280934 in webkit


Ignore:
Timestamp:
Aug 11, 2021, 3:25:56 PM (5 years ago)
Author:
sihui_liu@apple.com
Message:

Suspend WorkQueue of ResourceLoadStatistics and LocalStorage sooner
​https://bugs.webkit.org/show_bug.cgi?id=228748
<rdar://problem/81626714>

Reviewed by Chris Dumez.

Source/WebKit:

When suspending ResourceLoadStatistics and LocalStorage, we dispatched a suspend task, which waits on a
condition, to their WorkQueue. That means the queue will be suspended after completing all tasks scheduled
before the suspend task. These tasks may take a long time to complete and assertion may be timed out.

When network process receives PrepareToSuspend message, we want the queues to suspend as soon as possible. To
achieve that, now we check if the queue needs to be suspended before each task, which ensures the queue
execute as most one task after suspend().

  • NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.cpp:

(WebKit::ResourceLoadStatisticsDatabaseStore::ResourceLoadStatisticsDatabaseStore):

  • NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.h:
  • NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp:

(WebKit::ResourceLoadStatisticsMemoryStore::ResourceLoadStatisticsMemoryStore):

  • NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h:
  • NetworkProcess/Classifier/ResourceLoadStatisticsStore.cpp:

(WebKit::ResourceLoadStatisticsStore::ResourceLoadStatisticsStore):

  • NetworkProcess/Classifier/ResourceLoadStatisticsStore.h:

(WebKit::ResourceLoadStatisticsStore::workQueue):

  • NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp:

(WebKit::sharedStatisticsQueue):
(WebKit::WebResourceLoadStatisticsStore::suspend):
(WebKit::WebResourceLoadStatisticsStore::resume):
(WebKit::WTF_GUARDED_BY_LOCK): Deleted.

  • NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h:
  • NetworkProcess/WebStorage/LocalStorageDatabase.cpp:

(WebKit::LocalStorageDatabase::create):
(WebKit::LocalStorageDatabase::LocalStorageDatabase):

  • NetworkProcess/WebStorage/LocalStorageDatabase.h:
  • NetworkProcess/WebStorage/LocalStorageNamespace.cpp:

(WebKit::LocalStorageNamespace::getOrCreateStorageArea):

  • NetworkProcess/WebStorage/LocalStorageNamespace.h:
  • NetworkProcess/WebStorage/SessionStorageNamespace.cpp:

(WebKit::SessionStorageNamespace::getOrCreateStorageArea):

  • NetworkProcess/WebStorage/SessionStorageNamespace.h:
  • NetworkProcess/WebStorage/StorageArea.cpp:

(WebKit::StorageArea::StorageArea):

  • NetworkProcess/WebStorage/StorageArea.h:
  • NetworkProcess/WebStorage/StorageManager.cpp:

(WebKit::StorageManager::createLocalStorageArea):
(WebKit::StorageManager::createTransientLocalStorageArea):
(WebKit::StorageManager::createSessionStorageArea):

  • NetworkProcess/WebStorage/StorageManager.h:
  • NetworkProcess/WebStorage/StorageManagerSet.cpp:

(WebKit::StorageManagerSet::StorageManagerSet):
(WebKit::StorageManagerSet::suspend):
(WebKit::StorageManagerSet::resume):

  • NetworkProcess/WebStorage/StorageManagerSet.h:

(WebKit::StorageManagerSet::WTF_GUARDED_BY_LOCK): Deleted.

  • NetworkProcess/WebStorage/TransientLocalStorageNamespace.cpp:

(WebKit::TransientLocalStorageNamespace::getOrCreateStorageArea):

  • NetworkProcess/WebStorage/TransientLocalStorageNamespace.h:

Source/WTF:

Add SuspendableWorkQueue that would perform suspend check before each task.

  • WTF.xcodeproj/project.pbxproj:
  • wtf/CMakeLists.txt:
  • wtf/Forward.h:
  • wtf/SuspendableWorkQueue.cpp: Added.

(WTF::SuspendableWorkQueue::create):
(WTF::SuspendableWorkQueue::SuspendableWorkQueue):
(WTF::SuspendableWorkQueue::suspend):
(WTF::SuspendableWorkQueue::resume):
(WTF::SuspendableWorkQueue::dispatch):
(WTF::SuspendableWorkQueue::dispatchAfter):
(WTF::SuspendableWorkQueue::dispatchSync):
(WTF::SuspendableWorkQueue::invokeAllSuspensionCompletionHandlers):
(WTF::SuspendableWorkQueue::suspendIfNeeded):

  • wtf/SuspendableWorkQueue.h: Added.
  • wtf/WorkQueue.h:

(): Deleted.

Location:
trunk/Source
Files:
2 added
28 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r280908 r280934  
     12021-08-11  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Suspend WorkQueue of ResourceLoadStatistics and LocalStorage sooner
     4        https://bugs.webkit.org/show_bug.cgi?id=228748
     5        <rdar://problem/81626714>
     6
     7        Reviewed by Chris Dumez.
     8
     9        Add SuspendableWorkQueue that would perform suspend check before each task.
     10
     11        * WTF.xcodeproj/project.pbxproj:
     12        * wtf/CMakeLists.txt:
     13        * wtf/Forward.h:
     14        * wtf/SuspendableWorkQueue.cpp: Added.
     15        (WTF::SuspendableWorkQueue::create):
     16        (WTF::SuspendableWorkQueue::SuspendableWorkQueue):
     17        (WTF::SuspendableWorkQueue::suspend):
     18        (WTF::SuspendableWorkQueue::resume):
     19        (WTF::SuspendableWorkQueue::dispatch):
     20        (WTF::SuspendableWorkQueue::dispatchAfter):
     21        (WTF::SuspendableWorkQueue::dispatchSync):
     22        (WTF::SuspendableWorkQueue::invokeAllSuspensionCompletionHandlers):
     23        (WTF::SuspendableWorkQueue::suspendIfNeeded):
     24        * wtf/SuspendableWorkQueue.h: Added.
     25        * wtf/WorkQueue.h:
     26        (): Deleted.
     27
    1282021-08-11  Youenn Fablet  <youenn@apple.com>
    229

  • trunk/Source/WTF/WTF.xcodeproj/project.pbxproj

    r280795 r280934  
    103103                93934BD318A1E8C300D0D6A1 /* StringViewCocoa.mm in Sources */ = {isa = PBXBuildFile; fileRef = 93934BD218A1E8C300D0D6A1 /* StringViewCocoa.mm */; };
    104104                93934BD518A1F16900D0D6A1 /* StringViewCF.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93934BD418A1F16900D0D6A1 /* StringViewCF.cpp */; };
     105                93B07ED826B8717000A09B34 /* SuspendableWorkQueue.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93B07ED726B8715B00A09B34 /* SuspendableWorkQueue.cpp */; };
    105106                93B5B44E2213D616004B7AA7 /* HexNumber.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93B5B44D2213D616004B7AA7 /* HexNumber.cpp */; };
    106107                93B5B45122171EEA004B7AA7 /* Logger.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 93B5B45022171EE9004B7AA7 /* Logger.cpp */; };
    … …  
    511512                93934BD418A1F16900D0D6A1 /* StringViewCF.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StringViewCF.cpp; sourceTree = "<group>"; };
    512513                93AC91A718942FC400244939 /* LChar.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LChar.h; sourceTree = "<group>"; };
     514                93B07ED626B86BB500A09B34 /* SuspendableWorkQueue.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SuspendableWorkQueue.h; sourceTree = "<group>"; };
     515                93B07ED726B8715B00A09B34 /* SuspendableWorkQueue.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = SuspendableWorkQueue.cpp; sourceTree = "<group>"; };
    513516                93B5B44D2213D616004B7AA7 /* HexNumber.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HexNumber.cpp; sourceTree = "<group>"; };
    514517                93B5B45022171EE9004B7AA7 /* Logger.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Logger.cpp; sourceTree = "<group>"; };
    … …  
    13121315                                0FDDBFA51666DFA300C55FEF /* StringPrintStream.cpp */,
    13131316                                0FDDBFA61666DFA300C55FEF /* StringPrintStream.h */,
     1317                                93B07ED726B8715B00A09B34 /* SuspendableWorkQueue.cpp */,
     1318                                93B07ED626B86BB500A09B34 /* SuspendableWorkQueue.h */,
    13141319                                5597F82C1D94B9970066BC21 /* SynchronizedFixedQueue.h */,
    13151320                                E3E158251EADA53C004A079D /* SystemFree.h */,
    … …  
    18251830                                93934BD318A1E8C300D0D6A1 /* StringViewCocoa.mm in Sources */,
    18261831                                A8A473B7151A825B004123FF /* strtod.cc in Sources */,
     1832                                93B07ED826B8717000A09B34 /* SuspendableWorkQueue.cpp in Sources */,
    18271833                                52183012C99E476A84EEBEA8 /* SymbolImpl.cpp in Sources */,
    18281834                                70A993FE1AD7151300FA615B /* SymbolRegistry.cpp in Sources */,

  • trunk/Source/WTF/wtf/CMakeLists.txt

    r280795 r280934  
    267267    StringHashDumpContext.h
    268268    StringPrintStream.h
     269    SuspendableWorkQueue.h
    269270    SynchronizedFixedQueue.h
    270271    SystemFree.h
    … …  
    463464    StackTrace.cpp
    464465    StringPrintStream.cpp
     466    SuspendableWorkQueue.cpp
    465467    ThreadGroup.cpp
    466468    ThreadMessage.cpp

  • trunk/Source/WTF/wtf/Forward.h

    r280559 r280934  
    4545class StringImpl;
    4646class StringView;
     47class SuspendableWorkQueue;
    4748class TextPosition;
    4849class TextStream;
    … …  
    152153using WTF::StringParsingBuffer;
    153154using WTF::StringView;
     155using WTF::SuspendableWorkQueue;
    154156using WTF::TextPosition;
    155157using WTF::TextStream;

  • trunk/Source/WTF/wtf/WorkQueue.h

    r274307 r280934  
    4242namespace WTF {
    4343
    44 class WorkQueue final : public FunctionDispatcher {
     44class WorkQueue : public FunctionDispatcher {
    4545
    4646public:
    … …  
    5454
    5555    WTF_EXPORT_PRIVATE static Ref<WorkQueue> create(const char* name, Type = Type::Serial, QOS = QOS::Default);
    56     ~WorkQueue() final;
     56    ~WorkQueue() override;
    5757
    58     WTF_EXPORT_PRIVATE void dispatch(Function<void()>&&) final;
    59     WTF_EXPORT_PRIVATE void dispatchAfter(Seconds, Function<void()>&&);
    60     WTF_EXPORT_PRIVATE void dispatchSync(Function<void()>&&);
     58    WTF_EXPORT_PRIVATE void dispatch(Function<void()>&&) override;
     59    WTF_EXPORT_PRIVATE virtual void dispatchAfter(Seconds, Function<void()>&&);
     60    WTF_EXPORT_PRIVATE virtual void dispatchSync(Function<void()>&&);
    6161
    6262    WTF_EXPORT_PRIVATE static void concurrentApply(size_t iterations, WTF::Function<void(size_t index)>&&);
    … …  
    6868#endif
    6969
    70 private:
     70protected:
    7171    WorkQueue(const char* name, Type, QOS);
    7272
     73private:
    7374    static Ref<WorkQueue> constructMainWorkQueue();
    7475#if USE(COCOA_EVENT_LOOP)

  • trunk/Source/WebKit/ChangeLog

    r280928 r280934  
     12021-08-11  Sihui Liu  <sihui_liu@apple.com>
     2
     3        Suspend WorkQueue of ResourceLoadStatistics and LocalStorage sooner
     4        https://bugs.webkit.org/show_bug.cgi?id=228748
     5        <rdar://problem/81626714>
     6
     7        Reviewed by Chris Dumez.
     8
     9        When suspending ResourceLoadStatistics and LocalStorage, we dispatched a suspend task, which waits on a
     10        condition, to their WorkQueue. That means the queue will be suspended after completing all tasks scheduled
     11        before the suspend task. These tasks may take a long time to complete and assertion may be timed out.
     12
     13        When network process receives PrepareToSuspend message, we want the queues to suspend as soon as possible. To
     14        achieve that, now we check if the queue needs to be suspended before each task, which ensures the queue
     15        execute as most one task after suspend().
     16
     17        * NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.cpp:
     18        (WebKit::ResourceLoadStatisticsDatabaseStore::ResourceLoadStatisticsDatabaseStore):
     19        * NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.h:
     20        * NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp:
     21        (WebKit::ResourceLoadStatisticsMemoryStore::ResourceLoadStatisticsMemoryStore):
     22        * NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h:
     23        * NetworkProcess/Classifier/ResourceLoadStatisticsStore.cpp:
     24        (WebKit::ResourceLoadStatisticsStore::ResourceLoadStatisticsStore):
     25        * NetworkProcess/Classifier/ResourceLoadStatisticsStore.h:
     26        (WebKit::ResourceLoadStatisticsStore::workQueue):
     27        * NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp:
     28        (WebKit::sharedStatisticsQueue):
     29        (WebKit::WebResourceLoadStatisticsStore::suspend):
     30        (WebKit::WebResourceLoadStatisticsStore::resume):
     31        (WebKit::WTF_GUARDED_BY_LOCK): Deleted.
     32        * NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h:
     33        * NetworkProcess/WebStorage/LocalStorageDatabase.cpp:
     34        (WebKit::LocalStorageDatabase::create):
     35        (WebKit::LocalStorageDatabase::LocalStorageDatabase):
     36        * NetworkProcess/WebStorage/LocalStorageDatabase.h:
     37        * NetworkProcess/WebStorage/LocalStorageNamespace.cpp:
     38        (WebKit::LocalStorageNamespace::getOrCreateStorageArea):
     39        * NetworkProcess/WebStorage/LocalStorageNamespace.h:
     40        * NetworkProcess/WebStorage/SessionStorageNamespace.cpp:
     41        (WebKit::SessionStorageNamespace::getOrCreateStorageArea):
     42        * NetworkProcess/WebStorage/SessionStorageNamespace.h:
     43        * NetworkProcess/WebStorage/StorageArea.cpp:
     44        (WebKit::StorageArea::StorageArea):
     45        * NetworkProcess/WebStorage/StorageArea.h:
     46        * NetworkProcess/WebStorage/StorageManager.cpp:
     47        (WebKit::StorageManager::createLocalStorageArea):
     48        (WebKit::StorageManager::createTransientLocalStorageArea):
     49        (WebKit::StorageManager::createSessionStorageArea):
     50        * NetworkProcess/WebStorage/StorageManager.h:
     51        * NetworkProcess/WebStorage/StorageManagerSet.cpp:
     52        (WebKit::StorageManagerSet::StorageManagerSet):
     53        (WebKit::StorageManagerSet::suspend):
     54        (WebKit::StorageManagerSet::resume):
     55        * NetworkProcess/WebStorage/StorageManagerSet.h:
     56        (WebKit::StorageManagerSet::WTF_GUARDED_BY_LOCK): Deleted.
     57        * NetworkProcess/WebStorage/TransientLocalStorageNamespace.cpp:
     58        (WebKit::TransientLocalStorageNamespace::getOrCreateStorageArea):
     59        * NetworkProcess/WebStorage/TransientLocalStorageNamespace.h:
     60
    1612021-08-11  Dana Estra  <destra@apple.com>
    262

  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.cpp

    r280157 r280934  
    5353#include <wtf/Scope.h>
    5454#include <wtf/StdSet.h>
     55#include <wtf/SuspendableWorkQueue.h>
    5556#include <wtf/text/StringBuilder.h>
    5657
    … …  
    347348}
    348349
    349 ResourceLoadStatisticsDatabaseStore::ResourceLoadStatisticsDatabaseStore(WebResourceLoadStatisticsStore& store, WorkQueue& workQueue, ShouldIncludeLocalhost shouldIncludeLocalhost, const String& storageDirectoryPath, PAL::SessionID sessionID)
     350ResourceLoadStatisticsDatabaseStore::ResourceLoadStatisticsDatabaseStore(WebResourceLoadStatisticsStore& store, SuspendableWorkQueue& workQueue, ShouldIncludeLocalhost shouldIncludeLocalhost, const String& storageDirectoryPath, PAL::SessionID sessionID)
    350351    : ResourceLoadStatisticsStore(store, workQueue, shouldIncludeLocalhost)
    351352    , m_storageDirectoryPath(FileSystem::pathByAppendingComponent(storageDirectoryPath, "observations.db"_s))

  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsDatabaseStore.h

    r280157 r280934  
    3939#include <wtf/StdSet.h>
    4040#include <wtf/Vector.h>
    41 #include <wtf/WorkQueue.h>
    4241
    4342namespace WebCore {
    … …  
    7776class ResourceLoadStatisticsDatabaseStore final : public ResourceLoadStatisticsStore {
    7877public:
    79     ResourceLoadStatisticsDatabaseStore(WebResourceLoadStatisticsStore&, WorkQueue&, ShouldIncludeLocalhost, const String& storageDirectoryPath, PAL::SessionID);
     78    ResourceLoadStatisticsDatabaseStore(WebResourceLoadStatisticsStore&, SuspendableWorkQueue&, ShouldIncludeLocalhost, const String& storageDirectoryPath, PAL::SessionID);
    8079    ~ResourceLoadStatisticsDatabaseStore();
    8180

  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.cpp

    r278253 r280934  
    7070}
    7171
    72 ResourceLoadStatisticsMemoryStore::ResourceLoadStatisticsMemoryStore(WebResourceLoadStatisticsStore& store, WorkQueue& workQueue, ShouldIncludeLocalhost shouldIncludeLocalhost)
     72ResourceLoadStatisticsMemoryStore::ResourceLoadStatisticsMemoryStore(WebResourceLoadStatisticsStore& store, SuspendableWorkQueue& workQueue, ShouldIncludeLocalhost shouldIncludeLocalhost)
    7373    : ResourceLoadStatisticsStore(store, workQueue, shouldIncludeLocalhost)
    7474{

  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsMemoryStore.h

    r278253 r280934  
    3333#include <wtf/Vector.h>
    3434#include <wtf/WeakPtr.h>
    35 #include <wtf/WorkQueue.h>
    3635
    3736namespace WebCore {
    … …  
    4847class ResourceLoadStatisticsMemoryStore final : public ResourceLoadStatisticsStore {
    4948public:
    50     ResourceLoadStatisticsMemoryStore(WebResourceLoadStatisticsStore&, WorkQueue&, ShouldIncludeLocalhost);
     49    ResourceLoadStatisticsMemoryStore(WebResourceLoadStatisticsStore&, SuspendableWorkQueue&, ShouldIncludeLocalhost);
    5150
    5251    void clear(CompletionHandler<void()>&&) override;

  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.cpp

    r278185 r280934  
    107107}
    108108
    109 ResourceLoadStatisticsStore::ResourceLoadStatisticsStore(WebResourceLoadStatisticsStore& store, WorkQueue& workQueue, ShouldIncludeLocalhost shouldIncludeLocalhost)
     109ResourceLoadStatisticsStore::ResourceLoadStatisticsStore(WebResourceLoadStatisticsStore& store, SuspendableWorkQueue& workQueue, ShouldIncludeLocalhost shouldIncludeLocalhost)
    110110    : m_store(store)
    111111    , m_workQueue(workQueue)

  • trunk/Source/WebKit/NetworkProcess/Classifier/ResourceLoadStatisticsStore.h

    r278253 r280934  
    3333#include <WebCore/FrameIdentifier.h>
    3434#include <wtf/CompletionHandler.h>
     35#include <wtf/Forward.h>
    3536#include <wtf/Vector.h>
    3637#include <wtf/WeakPtr.h>
    37 #include <wtf/WorkQueue.h>
    3838
    3939#if HAVE(CORE_PREDICTION)
    … …  
    218218    static unsigned computeImportance(const WebCore::ResourceLoadStatistics&);
    219219
    220     ResourceLoadStatisticsStore(WebResourceLoadStatisticsStore&, WorkQueue&, ShouldIncludeLocalhost);
     220    ResourceLoadStatisticsStore(WebResourceLoadStatisticsStore&, SuspendableWorkQueue&, ShouldIncludeLocalhost);
    221221   
    222222    bool dataRecordsBeingRemoved() const { return m_dataRecordsBeingRemoved; }
    … …  
    229229
    230230    WebResourceLoadStatisticsStore& store() { return m_store; }
    231     Ref<WorkQueue>& workQueue() { return m_workQueue; }
     231    Ref<SuspendableWorkQueue>& workQueue() { return m_workQueue; }
    232232#if HAVE(CORE_PREDICTION)
    233233    ResourceLoadStatisticsClassifierCocoa& classifier() { return m_resourceLoadStatisticsClassifier; }
    … …  
    279279
    280280    WebResourceLoadStatisticsStore& m_store;
    281     Ref<WorkQueue> m_workQueue;
     281    Ref<SuspendableWorkQueue> m_workQueue;
    282282#if HAVE(CORE_PREDICTION)
    283283    ResourceLoadStatisticsClassifierCocoa m_resourceLoadStatisticsClassifier;

  • trunk/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.cpp

    r280110 r280934  
    5555#include <wtf/CrossThreadCopier.h>
    5656#include <wtf/NeverDestroyed.h>
     57#include <wtf/SuspendableWorkQueue.h>
    5758#include <wtf/threads/BinarySemaphore.h>
    5859
    5960namespace WebKit {
    6061using namespace WebCore;
    61 
    62 static Lock globalSuspensionLock;
    63 static Condition globalSuspensionCondition;
    64 static bool globalShouldSuspend WTF_GUARDED_BY_LOCK(globalSuspensionLock) { false };
    65 static uint64_t globalSuspensionIdentifier WTF_GUARDED_BY_LOCK(globalSuspensionLock) { 0 };
    6662
    6763const OptionSet<WebsiteDataType>& WebResourceLoadStatisticsStore::monitoredDataTypes()
    … …  
    148144}
    149145
    150 static Ref<WorkQueue> sharedStatisticsQueue()
    151 {
    152     static NeverDestroyed<Ref<WorkQueue>> queue(WorkQueue::create("WebResourceLoadStatisticsStore Process Data Queue", WorkQueue::Type::Serial, WorkQueue::QOS::Utility));
     146static Ref<SuspendableWorkQueue> sharedStatisticsQueue()
     147{
     148    static NeverDestroyed<Ref<SuspendableWorkQueue>> queue(SuspendableWorkQueue::create("WebResourceLoadStatisticsStore Process Data Queue", WorkQueue::QOS::Utility));
    153149    return queue.get().copyRef();
    154150}
    … …  
    14491445void WebResourceLoadStatisticsStore::suspend(CompletionHandler<void()>&& completionHandler)
    14501446{
    1451     Locker suspensionLocker { globalSuspensionLock };
    1452     globalShouldSuspend = true;
    1453 
    1454     sharedStatisticsQueue()->dispatch([suspensionIdentifier = ++globalSuspensionIdentifier, completionHandler = WTFMove(completionHandler)] () mutable {
    1455         Locker suspensionLocker { globalSuspensionLock };
    1456         if (!globalShouldSuspend || suspensionIdentifier != globalSuspensionIdentifier) {
    1457             postTaskReply(WTFMove(completionHandler));
    1458             return;
    1459         }
    1460 
     1447    ASSERT(RunLoop::isMain());
     1448
     1449    sharedStatisticsQueue()->suspend([]() mutable {
    14611450        for (auto& databaseStore : ResourceLoadStatisticsDatabaseStore::allStores())
    14621451            databaseStore->interrupt();
    1463 
    1464         postTaskReply(WTFMove(completionHandler));
    1465 
    1466         while (globalShouldSuspend)
    1467             globalSuspensionCondition.wait(globalSuspensionLock);
    1468     });
     1452    }, WTFMove(completionHandler));
    14691453}
    14701454
    … …  
    14731457    ASSERT(RunLoop::isMain());
    14741458
    1475     Locker suspensionLocker { globalSuspensionLock };
    1476     globalShouldSuspend = false;
    1477     globalSuspensionCondition.notifyOne();
     1459    sharedStatisticsQueue()->resume();
    14781460}
    14791461

  • trunk/Source/WebKit/NetworkProcess/Classifier/WebResourceLoadStatisticsStore.h

    r280110 r280934  
    4343#include <wtf/CompletionHandler.h>
    4444#include <wtf/Condition.h>
     45#include <wtf/Forward.h>
    4546#include <wtf/Lock.h>
    4647#include <wtf/RunLoop.h>
    … …  
    5051#include <wtf/WeakPtr.h>
    5152#include <wtf/text/WTFString.h>
    52 
    53 namespace WTF {
    54 class WorkQueue;
    55 }
    5653
    5754namespace WebCore {
    … …  
    145142    static const OptionSet<WebsiteDataType>& monitoredDataTypes();
    146143
    147     WTF::WorkQueue& statisticsQueue() { return m_statisticsQueue.get(); }
     144    SuspendableWorkQueue& statisticsQueue() { return m_statisticsQueue.get(); }
    148145
    149146    void populateMemoryStoreFromDisk(CompletionHandler<void()>&&);
    … …  
    277274
    278275    WeakPtr<NetworkSession> m_networkSession;
    279     Ref<WTF::WorkQueue> m_statisticsQueue;
     276    Ref<SuspendableWorkQueue> m_statisticsQueue;
    280277    std::unique_ptr<ResourceLoadStatisticsStore> m_statisticsStore;
    281278

  • trunk/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabase.cpp

    r278786 r280934  
    3535#include <wtf/HashMap.h>
    3636#include <wtf/RefPtr.h>
     37#include <wtf/SuspendableWorkQueue.h>
    3738
    3839namespace WebKit {
    … …  
    4344constexpr Seconds transactionDuration { 500_ms };
    4445
    45 Ref<LocalStorageDatabase> LocalStorageDatabase::create(Ref<WorkQueue>&& workQueue, String&& databasePath, unsigned quotaInBytes)
     46Ref<LocalStorageDatabase> LocalStorageDatabase::create(Ref<SuspendableWorkQueue>&& workQueue, String&& databasePath, unsigned quotaInBytes)
    4647{
    4748    return adoptRef(*new LocalStorageDatabase(WTFMove(workQueue), WTFMove(databasePath), quotaInBytes));
    4849}
    4950
    50 LocalStorageDatabase::LocalStorageDatabase(Ref<WorkQueue>&& workQueue, String&& databasePath, unsigned quotaInBytes)
     51LocalStorageDatabase::LocalStorageDatabase(Ref<SuspendableWorkQueue>&& workQueue, String&& databasePath, unsigned quotaInBytes)
    5152    : m_workQueue(WTFMove(workQueue))
    5253    , m_databasePath(WTFMove(databasePath))

  • trunk/Source/WebKit/NetworkProcess/WebStorage/LocalStorageDatabase.h

    r278786 r280934  
    2727
    2828#include <WebCore/SQLiteDatabase.h>
     29#include <wtf/Forward.h>
    2930#include <wtf/HashMap.h>
    3031#include <wtf/WeakPtr.h>
    31 #include <wtf/WorkQueue.h>
    3232
    3333namespace WebCore {
    … …  
    4242class LocalStorageDatabase : public RefCounted<LocalStorageDatabase>, public CanMakeWeakPtr<LocalStorageDatabase> {
    4343public:
    44     static Ref<LocalStorageDatabase> create(Ref<WorkQueue>&&, String&& databasePath, unsigned quotaInBytes);
     44    static Ref<LocalStorageDatabase> create(Ref<SuspendableWorkQueue>&&, String&& databasePath, unsigned quotaInBytes);
    4545    ~LocalStorageDatabase();
    4646
    … …  
    5959
    6060private:
    61     LocalStorageDatabase(Ref<WorkQueue>&&, String&& databasePath, unsigned quotaInBytes);
     61    LocalStorageDatabase(Ref<SuspendableWorkQueue>&&, String&& databasePath, unsigned quotaInBytes);
    6262
    6363    enum class ShouldCreateDatabase : bool { No, Yes };
    … …  
    7272    WebCore::SQLiteStatementAutoResetScope scopedStatement(std::unique_ptr<WebCore::SQLiteStatement>&, ASCIILiteral query) const;
    7373
    74     Ref<WorkQueue> m_workQueue;
     74    Ref<SuspendableWorkQueue> m_workQueue;
    7575    String m_databasePath;
    7676    mutable WebCore::SQLiteDatabase m_database;

  • trunk/Source/WebKit/NetworkProcess/WebStorage/LocalStorageNamespace.cpp

    r276653 r280934  
    4848}
    4949
    50 StorageArea& LocalStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin, IsEphemeral isEphemeral, Ref<WorkQueue>&& workQueue)
     50StorageArea& LocalStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin, IsEphemeral isEphemeral, Ref<SuspendableWorkQueue>&& workQueue)
    5151{
    5252    ASSERT(!RunLoop::isMain());

  • trunk/Source/WebKit/NetworkProcess/WebStorage/LocalStorageNamespace.h

    r275886 r280934  
    3232#include <wtf/HashMap.h>
    3333#include <wtf/WeakPtr.h>
    34 #include <wtf/WorkQueue.h>
    3534
    3635namespace WebKit {
    … …  
    4948
    5049    enum class IsEphemeral : bool { No, Yes };
    51     StorageArea& getOrCreateStorageArea(WebCore::SecurityOriginData&&, IsEphemeral, Ref<WorkQueue>&&);
     50    StorageArea& getOrCreateStorageArea(WebCore::SecurityOriginData&&, IsEphemeral, Ref<SuspendableWorkQueue>&&);
    5251
    5352    void clearStorageAreasMatchingOrigin(const WebCore::SecurityOriginData&);

  • trunk/Source/WebKit/NetworkProcess/WebStorage/SessionStorageNamespace.cpp

    r249533 r280934  
    4444}
    4545
    46 StorageArea& SessionStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin, Ref<WorkQueue>&& workQueue)
     46StorageArea& SessionStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin, Ref<SuspendableWorkQueue>&& workQueue)
    4747{
    4848    ASSERT(!RunLoop::isMain());

  • trunk/Source/WebKit/NetworkProcess/WebStorage/SessionStorageNamespace.h

    r249533 r280934  
    4545    bool isEmpty() const { return m_storageAreaMap.isEmpty(); }
    4646
    47     StorageArea& getOrCreateStorageArea(WebCore::SecurityOriginData&&, Ref<WorkQueue>&&);
     47    StorageArea& getOrCreateStorageArea(WebCore::SecurityOriginData&&, Ref<SuspendableWorkQueue>&&);
    4848
    4949    void cloneTo(SessionStorageNamespace& newSessionStorageNamespace);

  • trunk/Source/WebKit/NetworkProcess/WebStorage/StorageArea.cpp

    r278786 r280934  
    3131#include "StorageAreaMapMessages.h"
    3232#include "StorageManager.h"
     33#include <wtf/SuspendableWorkQueue.h>
    3334
    3435namespace WebKit {
    … …  
    3637using namespace WebCore;
    3738
    38 StorageArea::StorageArea(LocalStorageNamespace* localStorageNamespace, const SecurityOriginData& securityOrigin, unsigned quotaInBytes, Ref<WorkQueue>&& queue)
     39StorageArea::StorageArea(LocalStorageNamespace* localStorageNamespace, const SecurityOriginData& securityOrigin, unsigned quotaInBytes, Ref<SuspendableWorkQueue>&& queue)
    3940    : m_localStorageNamespace(makeWeakPtr(localStorageNamespace))
    4041    , m_securityOrigin(securityOrigin)

  • trunk/Source/WebKit/NetworkProcess/WebStorage/StorageArea.h

    r278786 r280934  
    4949    using Identifier = StorageAreaIdentifier;
    5050   
    51     StorageArea(LocalStorageNamespace*, const WebCore::SecurityOriginData&, unsigned quotaInBytes, Ref<WorkQueue>&&);
     51    StorageArea(LocalStorageNamespace*, const WebCore::SecurityOriginData&, unsigned quotaInBytes, Ref<SuspendableWorkQueue>&&);
    5252    ~StorageArea();
    5353
    … …  
    9191
    9292    Identifier m_identifier;
    93     Ref<WorkQueue> m_queue;
     93    Ref<SuspendableWorkQueue> m_queue;
    9494};
    9595

  • trunk/Source/WebKit/NetworkProcess/WebStorage/StorageManager.cpp

    r261038 r280934  
    4242#include <wtf/CrossThreadCopier.h>
    4343#include <wtf/FileSystem.h>
     44#include <wtf/SuspendableWorkQueue.h>
    4445#include <wtf/WorkQueue.h>
    4546
    … …  
    212213}
    213214
    214 StorageArea* StorageManager::createLocalStorageArea(StorageNamespaceIdentifier storageNamespaceID, SecurityOriginData&& origin, Ref<WorkQueue>&& workQueue)
     215StorageArea* StorageManager::createLocalStorageArea(StorageNamespaceIdentifier storageNamespaceID, SecurityOriginData&& origin, Ref<SuspendableWorkQueue>&& workQueue)
    215216{
    216217    ASSERT(!RunLoop::isMain());
    … …  
    222223}
    223224
    224 StorageArea* StorageManager::createTransientLocalStorageArea(StorageNamespaceIdentifier storageNamespaceID, SecurityOriginData&& topLevelOrigin, SecurityOriginData&& origin, Ref<WorkQueue>&& workQueue)
     225StorageArea* StorageManager::createTransientLocalStorageArea(StorageNamespaceIdentifier storageNamespaceID, SecurityOriginData&& topLevelOrigin, SecurityOriginData&& origin, Ref<SuspendableWorkQueue>&& workQueue)
    225226{
    226227    ASSERT(!RunLoop::isMain());
    … …  
    233234}
    234235
    235 StorageArea* StorageManager::createSessionStorageArea(StorageNamespaceIdentifier storageNamespaceID, SecurityOriginData&& origin, Ref<WorkQueue>&& workQueue)
     236StorageArea* StorageManager::createSessionStorageArea(StorageNamespaceIdentifier storageNamespaceID, SecurityOriginData&& origin, Ref<SuspendableWorkQueue>&& workQueue)
    236237{
    237238    ASSERT(!RunLoop::isMain());

  • trunk/Source/WebKit/NetworkProcess/WebStorage/StorageManager.h

    r274189 r280934  
    8181    static const unsigned localStorageDatabaseQuotaInBytes;
    8282
    83     StorageArea* createLocalStorageArea(StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, Ref<WorkQueue>&&);
    84     StorageArea* createTransientLocalStorageArea(StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, WebCore::SecurityOriginData&&, Ref<WorkQueue>&&);
    85     StorageArea* createSessionStorageArea(StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, Ref<WorkQueue>&&);
     83    StorageArea* createLocalStorageArea(StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, Ref<SuspendableWorkQueue>&&);
     84    StorageArea* createTransientLocalStorageArea(StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, WebCore::SecurityOriginData&&, Ref<SuspendableWorkQueue>&&);
     85    StorageArea* createSessionStorageArea(StorageNamespaceIdentifier, WebCore::SecurityOriginData&&, Ref<SuspendableWorkQueue>&&);
    8686
    8787    Vector<StorageAreaIdentifier> allStorageAreaIdentifiers() const;

  • trunk/Source/WebKit/NetworkProcess/WebStorage/StorageManagerSet.cpp

    r280110 r280934  
    4242
    4343StorageManagerSet::StorageManagerSet()
    44     : m_queue(WorkQueue::create("com.apple.WebKit.WebStorage"))
     44    : m_queue(SuspendableWorkQueue::create("com.apple.WebKit.WebStorage"))
    4545{
    4646    ASSERT(RunLoop::isMain());
    … …  
    178178    ASSERT(RunLoop::isMain());
    179179
    180     Locker suspensionLocker { m_suspensionLock };
    181     m_shouldSuspend = true;
    182 
    183     m_queue->dispatch([this, protectedThis = makeRef(*this), suspensionIdentifier = ++m_suspensionIdentifier, completionHandler = WTFMove(completionHandler)] () mutable {
    184         Locker suspensionLocker { m_suspensionLock };
    185         if (!m_shouldSuspend || suspensionIdentifier != m_suspensionIdentifier) {
    186             RunLoop::main().dispatch(WTFMove(completionHandler));
    187             return;
    188         }
    189 
    190         // Make sure we flush local storage to disk before we suspend the thread as we want to make sure any pending
    191         // SQL transaction has been committed.
    192         flushLocalStorage();
    193 
    194         RunLoop::main().dispatch(WTFMove(completionHandler));
    195 
    196         while (m_shouldSuspend)
    197             m_suspensionCondition.wait(m_suspensionLock);
    198     });
     180    m_queue->suspend([protectedThis = makeRef(*this)] {
     181        protectedThis->flushLocalStorage();
     182    }, WTFMove(completionHandler));
    199183}
    200184
    … …  
    203187    ASSERT(RunLoop::isMain());
    204188
    205     Locker suspensionLocker { m_suspensionLock };
    206     m_shouldSuspend = false;
    207     m_suspensionCondition.notifyOne();
     189    m_queue->resume();
    208190}
    209191

  • trunk/Source/WebKit/NetworkProcess/WebStorage/StorageManagerSet.h

    r280110 r280934  
    3434#include <wtf/Condition.h>
    3535#include <wtf/Lock.h>
     36#include <wtf/SuspendableWorkQueue.h>
    3637#include <wtf/WeakPtr.h>
    3738
    … …  
    99100
    100101    HashSet<IPC::Connection::UniqueID> m_connections;
    101     Ref<WorkQueue> m_queue;
    102 
    103     Lock m_suspensionLock;
    104     Condition m_suspensionCondition;
    105     bool m_shouldSuspend WTF_GUARDED_BY_LOCK(m_suspensionLock) { false };
    106     uint64_t m_suspensionIdentifier WTF_GUARDED_BY_LOCK(m_suspensionLock) { 0 };
     102    Ref<SuspendableWorkQueue> m_queue;
    107103};
    108104

  • trunk/Source/WebKit/NetworkProcess/WebStorage/TransientLocalStorageNamespace.cpp

    r249533 r280934  
    4545}
    4646
    47 StorageArea& TransientLocalStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin, Ref<WorkQueue>&& workQueue)
     47StorageArea& TransientLocalStorageNamespace::getOrCreateStorageArea(SecurityOriginData&& securityOrigin, Ref<SuspendableWorkQueue>&& workQueue)
    4848{
    4949    ASSERT(!RunLoop::isMain());

  • trunk/Source/WebKit/NetworkProcess/WebStorage/TransientLocalStorageNamespace.h

    r249533 r280934  
    4343    ~TransientLocalStorageNamespace();
    4444
    45     StorageArea& getOrCreateStorageArea(WebCore::SecurityOriginData&&, Ref<WorkQueue>&&);
     45    StorageArea& getOrCreateStorageArea(WebCore::SecurityOriginData&&, Ref<SuspendableWorkQueue>&&);
    4646    Vector<WebCore::SecurityOriginData> origins() const;
    4747
Note: See TracChangeset for help on using the changeset viewer.