Changeset 259540 in webkit


Ignore:
Timestamp:
Apr 4, 2020 5:03:45 PM (4 years ago)
Author:
Chris Dumez
Message:

[iOS] Simplify ProcessAssertion class in preparation for switch to RunningBoard
​https://bugs.webkit.org/show_bug.cgi?id=209984
<rdar://problem/61273941>

Reviewed by Darin Adler.

Source/WebKit:

Simplify ProcessAssertion class in preparation for switch to RunningBoard. There
is a slight mismatch between the way BKS and RunningBoard process assertion API.
This refactoring makes it so that we can use the same ProcessAssertion class in
WebKit to work with either BKS or RunningBoard. Support for RunningBoard will
come later.

In particular, the following changes were made:

  • Replace AssertionState & AssertionReason enums with a single ProcessAssertionType one since RunningBoard does not have 2 separate concepts.
  • Drop ProcessAssertion::setState() since it is not possible to change the flags on an existing RunningBoard assertion. Instead, we are expected to create a brand new process assertion of the expected type.
  • NetworkProcess/Downloads/DownloadMap.cpp:

(WebKit::DownloadMap::add):

  • Platform/IPC/cocoa/ConnectionCocoa.mm:

(IPC::ConnectionTerminationWatchdog::ConnectionTerminationWatchdog):

  • UIProcess/API/Cocoa/WKWebViewPrivateForTesting.h:
  • UIProcess/API/Cocoa/WKWebViewTesting.mm:

(-[WKWebView _setAssertionTypeForTesting:]):
(-[WKWebView _setAssertionStateForTesting:]): Deleted.

  • UIProcess/Downloads/DownloadProxyMap.cpp:

(WebKit::DownloadProxyMap::createDownloadProxy):

  • UIProcess/GPU/GPUProcessProxy.h:
  • UIProcess/Network/NetworkProcessProxy.cpp:

(WebKit::NetworkProcessProxy::sendProcessDidResume):
(WebKit::NetworkProcessProxy::takeUploadAssertion):
(WebKit::NetworkProcessProxy::didSetAssertionState): Deleted.

  • UIProcess/Network/NetworkProcessProxy.h:
  • UIProcess/ProcessAssertion.cpp:

(WebKit::ProcessAssertion::ProcessAssertion):
(WebKit::ProcessAssertion::setState): Deleted.

  • UIProcess/ProcessAssertion.h:

(WebKit::ProcessAssertion::type const):
(WebKit::ProcessAssertion::state const): Deleted.

  • UIProcess/ProcessThrottler.cpp:

(WebKit::ProcessThrottler::expectedAssertionType):
(WebKit::ProcessThrottler::updateAssertionTypeNow):
(WebKit::ProcessThrottler::setAssertionType):
(WebKit::ProcessThrottler::updateAssertionIfNeeded):
(WebKit::ProcessThrottler::didConnectToProcess):
(WebKit::ProcessThrottler::prepareToSuspendTimeoutTimerFired):
(WebKit::ProcessThrottler::processReadyToSuspend):
(WebKit::ProcessThrottler::sendPrepareToSuspendIPC):
(WebKit::ProcessThrottler::expectedAssertionState): Deleted.
(WebKit::ProcessThrottler::updateAssertionStateNow): Deleted.
(WebKit::ProcessThrottler::setAssertionState): Deleted.

  • UIProcess/ProcessThrottler.h:
  • UIProcess/ProcessThrottlerClient.h:

(WebKit::ProcessThrottlerClient::didSetAssertionType):

  • UIProcess/WebProcessPool.cpp:

(WebKit::WebProcessPool::setWebProcessHasUploads):
(WebKit::WebProcessPool::setWebProcessIsPlayingAudibleMedia):

  • UIProcess/WebProcessProxy.cpp:

(WebKit::WebProcessProxy::didSetAssertionType):
(WebKit::WebProcessProxy::didSetAssertionState): Deleted.

  • UIProcess/WebProcessProxy.h:

(WebKit::WebProcessProxy::setAssertionTypeForTesting):
(WebKit::WebProcessProxy::setAssertionStateForTesting): Deleted.

  • UIProcess/ios/ProcessAssertionIOS.mm:

(WebKit::flagsForAssertionType):
(WebKit::toBKSProcessAssertionReason):
(WebKit::ProcessAssertion::ProcessAssertion):
(WebKit::ProcessAndUIAssertion::updateRunInBackgroundCount):
(WebKit::ProcessAndUIAssertion::ProcessAndUIAssertion):
(WebKit::flagsForState): Deleted.
(WebKit::reasonForState): Deleted.
(WebKit::ProcessAssertion::setState): Deleted.
(WebKit::ProcessAndUIAssertion::setState): Deleted.

Tools:

  • TestWebKitAPI/Tests/WebKitCocoa/ServiceWorkerBasic.mm:
Location:
trunk
Files:
20 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebKit/ChangeLog

    r259539 r259540  
     12020-04-04  Chris Dumez  <cdumez@apple.com>
     2
     3        [iOS] Simplify ProcessAssertion class in preparation for switch to RunningBoard
     4        https://bugs.webkit.org/show_bug.cgi?id=209984
     5        <rdar://problem/61273941>
     6
     7        Reviewed by Darin Adler.
     8
     9        Simplify ProcessAssertion class in preparation for switch to RunningBoard. There
     10        is a slight mismatch between the way BKS and RunningBoard process assertion API.
     11        This refactoring makes it so that we can use the same ProcessAssertion class in
     12        WebKit to work with either BKS or RunningBoard. Support for RunningBoard will
     13        come later.
     14
     15        In particular, the following changes were made:
     16        - Replace AssertionState & AssertionReason enums with a single ProcessAssertionType
     17          one since RunningBoard does not have 2 separate concepts.
     18        - Drop ProcessAssertion::setState() since it is not possible to change the flags
     19          on an existing RunningBoard assertion. Instead, we are expected to create a
     20          brand new process assertion of the expected type.
     21
     22        * NetworkProcess/Downloads/DownloadMap.cpp:
     23        (WebKit::DownloadMap::add):
     24        * Platform/IPC/cocoa/ConnectionCocoa.mm:
     25        (IPC::ConnectionTerminationWatchdog::ConnectionTerminationWatchdog):
     26        * UIProcess/API/Cocoa/WKWebViewPrivateForTesting.h:
     27        * UIProcess/API/Cocoa/WKWebViewTesting.mm:
     28        (-[WKWebView _setAssertionTypeForTesting:]):
     29        (-[WKWebView _setAssertionStateForTesting:]): Deleted.
     30        * UIProcess/Downloads/DownloadProxyMap.cpp:
     31        (WebKit::DownloadProxyMap::createDownloadProxy):
     32        * UIProcess/GPU/GPUProcessProxy.h:
     33        * UIProcess/Network/NetworkProcessProxy.cpp:
     34        (WebKit::NetworkProcessProxy::sendProcessDidResume):
     35        (WebKit::NetworkProcessProxy::takeUploadAssertion):
     36        (WebKit::NetworkProcessProxy::didSetAssertionState): Deleted.
     37        * UIProcess/Network/NetworkProcessProxy.h:
     38        * UIProcess/ProcessAssertion.cpp:
     39        (WebKit::ProcessAssertion::ProcessAssertion):
     40        (WebKit::ProcessAssertion::setState): Deleted.
     41        * UIProcess/ProcessAssertion.h:
     42        (WebKit::ProcessAssertion::type const):
     43        (WebKit::ProcessAssertion::state const): Deleted.
     44        * UIProcess/ProcessThrottler.cpp:
     45        (WebKit::ProcessThrottler::expectedAssertionType):
     46        (WebKit::ProcessThrottler::updateAssertionTypeNow):
     47        (WebKit::ProcessThrottler::setAssertionType):
     48        (WebKit::ProcessThrottler::updateAssertionIfNeeded):
     49        (WebKit::ProcessThrottler::didConnectToProcess):
     50        (WebKit::ProcessThrottler::prepareToSuspendTimeoutTimerFired):
     51        (WebKit::ProcessThrottler::processReadyToSuspend):
     52        (WebKit::ProcessThrottler::sendPrepareToSuspendIPC):
     53        (WebKit::ProcessThrottler::expectedAssertionState): Deleted.
     54        (WebKit::ProcessThrottler::updateAssertionStateNow): Deleted.
     55        (WebKit::ProcessThrottler::setAssertionState): Deleted.
     56        * UIProcess/ProcessThrottler.h:
     57        * UIProcess/ProcessThrottlerClient.h:
     58        (WebKit::ProcessThrottlerClient::didSetAssertionType):
     59        * UIProcess/WebProcessPool.cpp:
     60        (WebKit::WebProcessPool::setWebProcessHasUploads):
     61        (WebKit::WebProcessPool::setWebProcessIsPlayingAudibleMedia):
     62        * UIProcess/WebProcessProxy.cpp:
     63        (WebKit::WebProcessProxy::didSetAssertionType):
     64        (WebKit::WebProcessProxy::didSetAssertionState): Deleted.
     65        * UIProcess/WebProcessProxy.h:
     66        (WebKit::WebProcessProxy::setAssertionTypeForTesting):
     67        (WebKit::WebProcessProxy::setAssertionStateForTesting): Deleted.
     68        * UIProcess/ios/ProcessAssertionIOS.mm:
     69        (WebKit::flagsForAssertionType):
     70        (WebKit::toBKSProcessAssertionReason):
     71        (WebKit::ProcessAssertion::ProcessAssertion):
     72        (WebKit::ProcessAndUIAssertion::updateRunInBackgroundCount):
     73        (WebKit::ProcessAndUIAssertion::ProcessAndUIAssertion):
     74        (WebKit::flagsForState): Deleted.
     75        (WebKit::reasonForState): Deleted.
     76        (WebKit::ProcessAssertion::setState): Deleted.
     77        (WebKit::ProcessAndUIAssertion::setState): Deleted.
     78
    1792020-04-04  David Kilzer  <ddkilzer@apple.com>
    280

  • trunk/Source/WebKit/NetworkProcess/Downloads/DownloadMap.cpp

    r248846 r259540  
    6262    if (m_downloads.size() == 1) {
    6363        ASSERT(!m_downloadAssertion);
    64         m_downloadAssertion = makeUnique<ProcessAssertion>(getpid(), "WebKit downloads"_s, AssertionState::UnboundedNetworking);
     64        m_downloadAssertion = makeUnique<ProcessAssertion>(getpid(), "WebKit downloads"_s, ProcessAssertionType::UnboundedNetworking);
    6565        RELEASE_LOG(ProcessSuspension, "Took 'WebKit downloads' assertion in NetworkProcess");
    6666    }

  • trunk/Source/WebKit/Platform/IPC/cocoa/ConnectionCocoa.mm

    r258369 r259540  
    8787        , m_watchdogTimer(RunLoop::main(), this, &ConnectionTerminationWatchdog::watchdogTimerFired)
    8888#if PLATFORM(IOS_FAMILY)
    89         , m_assertion(makeUnique<WebKit::ProcessAndUIAssertion>(xpc_connection_get_pid(m_xpcConnection.get()), "ConnectionTerminationWatchdog"_s, WebKit::AssertionState::Background))
     89        , m_assertion(makeUnique<WebKit::ProcessAndUIAssertion>(xpc_connection_get_pid(m_xpcConnection.get()), "ConnectionTerminationWatchdog"_s, WebKit::ProcessAssertionType::Background))
    9090#endif
    9191    {

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebViewPrivateForTesting.h

    r259200 r259540  
    5858@property (nonatomic, readonly) BOOL _hasServiceWorkerBackgroundActivityForTesting;
    5959@property (nonatomic, readonly) BOOL _hasServiceWorkerForegroundActivityForTesting;
    60 - (void)_setAssertionStateForTesting:(int)state;
     60- (void)_setAssertionTypeForTesting:(int)type;
    6161
    6262- (void)_doAfterProcessingAllPendingMouseEvents:(dispatch_block_t)action;

  • trunk/Source/WebKit/UIProcess/API/Cocoa/WKWebViewTesting.mm

    r259200 r259540  
    171171}
    172172
    173 - (void)_setAssertionStateForTesting:(int)value
     173- (void)_setAssertionTypeForTesting:(int)value
    174174{
    175175    if (!_page)
    176176        return;
    177177
    178     _page->process().setAssertionStateForTesting(static_cast<WebKit::AssertionState>(value));
     178    _page->process().setAssertionTypeForTesting(static_cast<WebKit::ProcessAssertionType>(value));
    179179}
    180180

  • trunk/Source/WebKit/UIProcess/Downloads/DownloadProxyMap.cpp

    r255845 r259540  
    9090    if (m_downloads.size() == 1 && m_shouldTakeAssertion) {
    9191        ASSERT(!m_downloadUIAssertion);
    92         m_downloadUIAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "WebKit downloads"_s, AssertionState::UnboundedNetworking);
     92        m_downloadUIAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "WebKit downloads"_s, ProcessAssertionType::UnboundedNetworking);
    9393
    9494        ASSERT(!m_downloadNetworkingAssertion);
    9595        RELEASE_ASSERT(m_process);
    96         m_downloadNetworkingAssertion = makeUnique<ProcessAssertion>(m_process->processIdentifier(), "WebKit downloads"_s, AssertionState::UnboundedNetworking);
     96        m_downloadNetworkingAssertion = makeUnique<ProcessAssertion>(m_process->processIdentifier(), "WebKit downloads"_s, ProcessAssertionType::UnboundedNetworking);
    9797
    9898        RELEASE_LOG(ProcessSuspension, "UIProcess took 'WebKit downloads' assertions for UIProcess and NetworkProcess");

  • trunk/Source/WebKit/UIProcess/GPU/GPUProcessProxy.h

    r258322 r259540  
    9393    // ProcessThrottlerClient
    9494    void sendPrepareToSuspend(IsSuspensionImminent, CompletionHandler<void()>&&) final { }
    95     void didSetAssertionState(AssertionState) final { }
    9695
    9796    // ProcessLauncher::Client

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.cpp

    r259521 r259540  
    11981198        send(Messages::NetworkProcess::ProcessDidResume(), 0);
    11991199}
    1200 
    1201 void NetworkProcessProxy::didSetAssertionState(AssertionState)
    1202 {
    1203 }
    12041200   
    12051201void NetworkProcessProxy::setIsHoldingLockedFiles(bool isHoldingLockedFiles)
    … …  
    14051401{
    14061402    ASSERT(!m_uploadAssertion);
    1407     m_uploadAssertion = makeUnique<ProcessAssertion>(processIdentifier(), "WebKit uploads"_s, AssertionState::UnboundedNetworking);
     1403    m_uploadAssertion = makeUnique<ProcessAssertion>(processIdentifier(), "WebKit uploads"_s, ProcessAssertionType::UnboundedNetworking);
    14081404}
    14091405

  • trunk/Source/WebKit/UIProcess/Network/NetworkProcessProxy.h

    r259275 r259540  
    240240    // ProcessThrottlerClient
    241241    void sendPrepareToSuspend(IsSuspensionImminent, CompletionHandler<void()>&&) final;
    242     void didSetAssertionState(AssertionState) final;
    243242
    244243    // IPC::Connection::Client

  • trunk/Source/WebKit/UIProcess/ProcessAssertion.cpp

    r244225 r259540  
    3333namespace WebKit {
    3434
    35 ProcessAssertion::ProcessAssertion(ProcessID, const String&, AssertionState assertionState)
    36     : m_assertionState(assertionState)
    37 {
    38 }
    39 
    40 ProcessAssertion::ProcessAssertion(pid_t pid, const String& name, AssertionState assertionState, AssertionReason)
    41     : m_assertionState(assertionState)
     35ProcessAssertion::ProcessAssertion(ProcessID, const String&, ProcessAssertionType assertionType)
     36    : m_assertionType(assertionType)
    4237{
    4338}
    … …  
    4540ProcessAssertion::~ProcessAssertion() = default;
    4641
    47 void ProcessAssertion::setState(AssertionState assertionState)
    48 {
    49     m_assertionState = assertionState;
    50 }
    51 
    5242} // namespace WebKit
    5343

  • trunk/Source/WebKit/UIProcess/ProcessAssertion.h

    r245255 r259540  
    4141
    4242namespace WebKit {
    43    
    44 enum class AssertionState {
     43
     44enum class ProcessAssertionType {
    4545    Suspended,
    4646    Background,
    4747    UnboundedNetworking,
    4848    Foreground,
    49 };
    50 
    51 enum class AssertionReason {
    52     Extension,
    53     FinishTask,
    54     FinishTaskUnbounded,
    5549    MediaPlayback,
    5650};
    … …  
    6559    };
    6660
    67     ProcessAssertion(ProcessID, const String& reason, AssertionState);
    68     ProcessAssertion(ProcessID, const String& reason, AssertionState, AssertionReason);
     61    ProcessAssertion(ProcessID, const String& reason, ProcessAssertionType);
    6962    virtual ~ProcessAssertion();
    7063
    … …  
    7265    Client* client() { return m_client; }
    7366
    74     AssertionState state() const { return m_assertionState; }
    75     virtual void setState(AssertionState);
     67    ProcessAssertionType type() const { return m_assertionType; }
    7668
    7769#if PLATFORM(IOS_FAMILY)
    … …  
    8880    Validity m_validity { Validity::Unset };
    8981#endif
    90     AssertionState m_assertionState;
     82    const ProcessAssertionType m_assertionType;
    9183    Client* m_client { nullptr };
    9284};
    … …  
    9688class ProcessAndUIAssertion final : public ProcessAssertion {
    9789public:
    98     ProcessAndUIAssertion(ProcessID, const String& reason, AssertionState);
     90    ProcessAndUIAssertion(ProcessID, const String& reason, ProcessAssertionType);
    9991    ~ProcessAndUIAssertion();
    10092
    101     void setState(AssertionState) final;
    10293    void uiAssertionWillExpireImminently();
    10394

  • trunk/Source/WebKit/UIProcess/ProcessThrottler.cpp

    r253980 r259540  
    8787}
    8888   
    89 AssertionState ProcessThrottler::expectedAssertionState()
     89ProcessAssertionType ProcessThrottler::expectedAssertionType()
    9090{
    9191    if (!m_foregroundActivities.isEmpty())
    92         return AssertionState::Foreground;
     92        return ProcessAssertionType::Foreground;
    9393    if (!m_backgroundActivities.isEmpty())
    94         return AssertionState::Background;
    95     return AssertionState::Suspended;
    96 }
    97    
    98 void ProcessThrottler::updateAssertionStateNow()
    99 {
    100     setAssertionState(expectedAssertionState());
    101 }
    102 
    103 void ProcessThrottler::setAssertionState(AssertionState newState)
    104 {
    105     RELEASE_ASSERT(m_assertion);
    106     if (m_assertion->state() == newState)
     94        return ProcessAssertionType::Background;
     95    return ProcessAssertionType::Suspended;
     96}
     97   
     98void ProcessThrottler::updateAssertionTypeNow()
     99{
     100    setAssertionType(expectedAssertionType());
     101}
     102
     103void ProcessThrottler::setAssertionType(ProcessAssertionType newType)
     104{
     105    if (m_assertion && m_assertion->type() == newType)
    107106        return;
    108107
    109     PROCESSTHROTTLER_RELEASE_LOG("setAssertionState: Updating process assertion state to %u (foregroundActivities: %u, backgroundActivities: %u)", newState, m_foregroundActivities.size(), m_backgroundActivities.size());
    110     m_assertion->setState(newState);
    111     m_process.didSetAssertionState(newState);
     108    PROCESSTHROTTLER_RELEASE_LOG("setAssertionType: Updating process assertion type to %u (foregroundActivities: %u, backgroundActivities: %u)", newType, m_foregroundActivities.size(), m_backgroundActivities.size());
     109    if (m_shouldTakeUIBackgroundAssertion)
     110        m_assertion = makeUnique<ProcessAndUIAssertion>(m_processIdentifier, "Web content visibility"_s, newType);
     111    else
     112        m_assertion = makeUnique<ProcessAssertion>(m_processIdentifier, "Web content visibility"_s, newType);
     113    m_process.didSetAssertionType(newType);
    112114}
    113115   
    … …  
    118120
    119121    if (shouldBeRunnable()) {
    120         if (m_assertion->state() == AssertionState::Suspended || m_pendingRequestToSuspendID) {
    121             if (m_assertion->state() == AssertionState::Suspended)
     122        if (m_assertion->type() == ProcessAssertionType::Suspended || m_pendingRequestToSuspendID) {
     123            if (m_assertion->type() == ProcessAssertionType::Suspended)
    122124                PROCESSTHROTTLER_RELEASE_LOG("updateAssertionIfNeeded: sending ProcessDidResume IPC because the process was suspended");
    123125            else
    … …  
    130132        // and clean up - move it to the background and send it a message to notify. Schedule a timeout so it can't stay running
    131133        // in the background for too long.
    132         if (m_assertion->state() != AssertionState::Suspended) {
     134        if (m_assertion->type() != ProcessAssertionType::Suspended) {
    133135            m_prepareToSuspendTimeoutTimer.startOneShot(processSuspensionTimeout);
    134136            sendPrepareToSuspendIPC(IsSuspensionImminent::No);
    … …  
    137139    }
    138140
    139     updateAssertionStateNow();
     141    updateAssertionTypeNow();
    140142}
    141143
    … …  
    145147    RELEASE_ASSERT(!m_assertion);
    146148
    147     if (m_shouldTakeUIBackgroundAssertion)
    148         m_assertion = makeUnique<ProcessAndUIAssertion>(pid, "Web content visibility"_s, expectedAssertionState());
    149     else
    150         m_assertion = makeUnique<ProcessAssertion>(pid, "Web content visibility"_s, expectedAssertionState());
    151 
    152149    m_processIdentifier = pid;
    153     m_process.didSetAssertionState(expectedAssertionState());
     150    setAssertionType(expectedAssertionType());
     151    RELEASE_ASSERT(m_assertion);
    154152    m_assertion->setClient(*this);
    155153}
    … …  
    159157    PROCESSTHROTTLER_RELEASE_LOG("prepareToSuspendTimeoutTimerFired: Updating process assertion to allow suspension");
    160158    RELEASE_ASSERT(m_pendingRequestToSuspendID);
    161     updateAssertionStateNow();
     159    updateAssertionTypeNow();
    162160}
    163161   
    … …  
    169167    clearPendingRequestToSuspend();
    170168
    171     if (m_assertion->state() != AssertionState::Suspended)
    172         updateAssertionStateNow();
     169    if (m_assertion->type() != ProcessAssertionType::Suspended)
     170        updateAssertionTypeNow();
    173171}
    174172
    … …  
    195193    }
    196194
    197     setAssertionState(isSuspensionImminent == IsSuspensionImminent::Yes ? AssertionState::Suspended : AssertionState::Background);
     195    setAssertionType(isSuspensionImminent == IsSuspensionImminent::Yes ? ProcessAssertionType::Suspended : ProcessAssertionType::Background);
    198196}
    199197

  • trunk/Source/WebKit/UIProcess/ProcessThrottler.h

    r256745 r259540  
    108108
    109109private:
    110     AssertionState expectedAssertionState();
     110    ProcessAssertionType expectedAssertionType();
    111111    void updateAssertionIfNeeded();
    112     void updateAssertionStateNow();
    113     void setAssertionState(AssertionState);
     112    void updateAssertionTypeNow();
     113    void setAssertionType(ProcessAssertionType);
    114114    void prepareToSuspendTimeoutTimerFired();
    115115    void sendPrepareToSuspendIPC(IsSuspensionImminent);

  • trunk/Source/WebKit/UIProcess/ProcessThrottlerClient.h

    r251599 r259540  
    3939    virtual void sendPrepareToSuspend(IsSuspensionImminent, CompletionHandler<void()>&&) = 0;
    4040    virtual void sendProcessDidResume() = 0;
    41     virtual void didSetAssertionState(AssertionState) = 0;
     41    virtual void didSetAssertionType(ProcessAssertionType) { };
    4242};
    4343

  • trunk/Source/WebKit/UIProcess/WebProcessPool.cpp

    r259516 r259540  
    23552355       
    23562356        ASSERT(!m_uiProcessUploadAssertion);
    2357         m_uiProcessUploadAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "WebKit uploads"_s, AssertionState::UnboundedNetworking);
     2357        m_uiProcessUploadAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "WebKit uploads"_s, ProcessAssertionType::UnboundedNetworking);
    23582358    }
    23592359   
    23602360    auto result = m_processesWithUploads.add(processID, nullptr);
    23612361    ASSERT(result.isNewEntry);
    2362     result.iterator->value = makeUnique<ProcessAssertion>(process->processIdentifier(), "WebKit uploads"_s, AssertionState::UnboundedNetworking);
     2362    result.iterator->value = makeUnique<ProcessAssertion>(process->processIdentifier(), "WebKit uploads"_s, ProcessAssertionType::UnboundedNetworking);
    23632363}
    23642364
    … …  
    23972397
    23982398        ASSERT(!m_uiProcessMediaPlaybackAssertion);
    2399         m_uiProcessMediaPlaybackAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "WebKit Media Playback"_s, AssertionState::Foreground, AssertionReason::MediaPlayback);
     2399        m_uiProcessMediaPlaybackAssertion = makeUnique<ProcessAssertion>(getCurrentProcessID(), "WebKit Media Playback"_s, ProcessAssertionType::MediaPlayback);
    24002400#if ENABLE(GPU_PROCESS)
    24012401        if (GPUProcessProxy::singletonIfCreated())
    2402             m_gpuProcessMediaPlaybackAssertion = makeUnique<ProcessAssertion>(GPUProcessProxy::singleton().processIdentifier(), "WebKit Media Playback"_s, AssertionState::Foreground, AssertionReason::MediaPlayback);
     2402            m_gpuProcessMediaPlaybackAssertion = makeUnique<ProcessAssertion>(GPUProcessProxy::singleton().processIdentifier(), "WebKit Media Playback"_s, ProcessAssertionType::MediaPlayback);
    24032403#endif
    24042404    }
    … …  
    24062406    auto result = m_processesPlayingAudibleMedia.add(processID, nullptr);
    24072407    ASSERT(result.isNewEntry);
    2408     result.iterator->value = makeUnique<ProcessAssertion>(process->processIdentifier(), "WebKit Media Playback"_s, AssertionState::Foreground, AssertionReason::MediaPlayback);
     2408    result.iterator->value = makeUnique<ProcessAssertion>(process->processIdentifier(), "WebKit Media Playback"_s, ProcessAssertionType::MediaPlayback);
    24092409}
    24102410

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.cpp

    r259505 r259540  
    13261326}
    13271327
    1328 void WebProcessProxy::didSetAssertionState(AssertionState state)
    1329 {
    1330     RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionState(%u)", this, state);
     1328void WebProcessProxy::didSetAssertionType(ProcessAssertionType type)
     1329{
     1330    RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionType(%u)", this, type);
    13311331
    13321332    if (isStandaloneServiceWorkerProcess()) {
    1333         RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionState() release all assertions for network process because this is a service worker process without page", this);
     1333        RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionType() release all assertions for network process because this is a service worker process without page", this);
    13341334        m_foregroundToken = nullptr;
    13351335        m_backgroundToken = nullptr;
    … …  
    13391339    ASSERT(!m_backgroundToken || !m_foregroundToken);
    13401340
    1341     switch (state) {
    1342     case AssertionState::Suspended:
    1343         RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionState(Suspended) release all assertions for network process", this);
     1341    switch (type) {
     1342    case ProcessAssertionType::Suspended:
     1343        RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionType(Suspended) release all assertions for network process", this);
    13441344        m_foregroundToken = nullptr;
    13451345        m_backgroundToken = nullptr;
    … …  
    13501350        break;
    13511351
    1352     case AssertionState::Background:
    1353         RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionState(Background) taking background assertion for network process", this);
     1352    case ProcessAssertionType::Background:
     1353        RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionType(Background) taking background assertion for network process", this);
    13541354        m_backgroundToken = processPool().backgroundWebProcessToken();
    13551355        m_foregroundToken = nullptr;
    13561356        break;
    13571357   
    1358     case AssertionState::Foreground:
    1359         RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionState(Foreground) taking foreground assertion for network process", this);
     1358    case ProcessAssertionType::Foreground:
     1359        RELEASE_LOG(ProcessSuspension, "%p - WebProcessProxy::didSetAssertionType(Foreground) taking foreground assertion for network process", this);
    13601360        m_foregroundToken = processPool().foregroundWebProcessToken();
    13611361        m_backgroundToken = nullptr;
    … …  
    13661366        break;
    13671367   
    1368     case AssertionState::UnboundedNetworking:
     1368    case ProcessAssertionType::MediaPlayback:
     1369    case ProcessAssertionType::UnboundedNetworking:
    13691370        ASSERT_NOT_REACHED();
    13701371    }

  • trunk/Source/WebKit/UIProcess/WebProcessProxy.h

    r259307 r259540  
    314314    void sendPrepareToSuspend(IsSuspensionImminent, CompletionHandler<void()>&&) final;
    315315    void sendProcessDidResume() final;
    316     void didSetAssertionState(AssertionState) final;
     316    void didSetAssertionType(ProcessAssertionType) final;
    317317
    318318#if PLATFORM(COCOA)
    … …  
    361361    bool hasServiceWorkerBackgroundActivityForTesting() const;
    362362#endif
    363     void setAssertionStateForTesting(AssertionState state) { didSetAssertionState(state); }
     363    void setAssertionTypeForTesting(ProcessAssertionType type) { didSetAssertionType(type); }
    364364
    365365#if PLATFORM(COCOA) && ENABLE(MEDIA_STREAM)

  • trunk/Source/WebKit/UIProcess/ios/ProcessAssertionIOS.mm

    r259414 r259540  
    272272const BKSProcessAssertionFlags foregroundTabFlags = (BKSProcessAssertionPreventTaskSuspend | BKSProcessAssertionWantsForegroundResourcePriority | BKSProcessAssertionPreventTaskThrottleDown);
    273273
    274 static BKSProcessAssertionFlags flagsForState(AssertionState assertionState)
    275 {
    276     switch (assertionState) {
    277     case AssertionState::Suspended:
     274static BKSProcessAssertionFlags flagsForAssertionType(ProcessAssertionType assertionType)
     275{
     276    switch (assertionType) {
     277    case ProcessAssertionType::Suspended:
    278278        return suspendedTabFlags;
    279     case AssertionState::Background:
    280     case AssertionState::UnboundedNetworking:
     279    case ProcessAssertionType::Background:
     280    case ProcessAssertionType::UnboundedNetworking:
    281281        return backgroundTabFlags;
    282     case AssertionState::Foreground:
     282    case ProcessAssertionType::Foreground:
     283    case ProcessAssertionType::MediaPlayback:
    283284        return foregroundTabFlags;
    284285    }
    285286}
    286287
    287 static AssertionReason reasonForState(AssertionState assertionState)
    288 {
    289     switch (assertionState) {
    290     case AssertionState::UnboundedNetworking:
    291         return AssertionReason::FinishTaskUnbounded;
    292     case AssertionState::Suspended:
    293     case AssertionState::Background:
    294     case AssertionState::Foreground:
    295         return AssertionReason::Extension;
    296     }
    297 }
    298 
    299 static BKSProcessAssertionReason toBKSProcessAssertionReason(AssertionReason reason)
    300 {
    301     switch (reason) {
    302     case AssertionReason::Extension:
     288static BKSProcessAssertionReason toBKSProcessAssertionReason(ProcessAssertionType assertionType)
     289{
     290    switch (assertionType) {
     291    case ProcessAssertionType::Suspended:
     292    case ProcessAssertionType::Background:
     293    case ProcessAssertionType::Foreground:
    303294        return BKSProcessAssertionReasonExtension;
    304     case AssertionReason::FinishTask:
    305         return BKSProcessAssertionReasonFinishTask;
    306     case AssertionReason::FinishTaskUnbounded:
     295    case ProcessAssertionType::UnboundedNetworking:
    307296        return BKSProcessAssertionReasonFinishTaskUnbounded;
    308     case AssertionReason::MediaPlayback:
     297    case ProcessAssertionType::MediaPlayback:
    309298        return BKSProcessAssertionReasonMediaPlayback;
    310299    }
    311300}
    312301
    313 ProcessAssertion::ProcessAssertion(pid_t pid, const String& name, AssertionState assertionState)
    314     : ProcessAssertion(pid, name, assertionState, reasonForState(assertionState))
    315 {
    316 }
    317 
    318 ProcessAssertion::ProcessAssertion(pid_t pid, const String& name, AssertionState assertionState, AssertionReason assertionReason)
    319     : m_assertionState(assertionState)
     302ProcessAssertion::ProcessAssertion(pid_t pid, const String& name, ProcessAssertionType assertionType)
     303    : m_assertionType(assertionType)
    320304{
    321305    auto weakThis = makeWeakPtr(*this);
    … …  
    331315    RELEASE_LOG(ProcessSuspension, "%p - ProcessAssertion() PID %d acquiring assertion for process with PID %d, name '%s'", this, getpid(), pid, name.utf8().data());
    332316   
    333     m_assertion = adoptNS([[BKSProcessAssertion alloc] initWithPID:pid flags:flagsForState(assertionState) reason:toBKSProcessAssertionReason(assertionReason) name:(NSString *)name withHandler:handler]);
     317    m_assertion = adoptNS([[BKSProcessAssertion alloc] initWithPID:pid flags:flagsForAssertionType(assertionType) reason:toBKSProcessAssertionReason(assertionType) name:(NSString *)name withHandler:handler]);
    334318    m_assertion.get().invalidationHandler = ^() {
    335319        dispatch_async(dispatch_get_main_queue(), ^{
    … …  
    357341}
    358342
    359 void ProcessAssertion::setState(AssertionState assertionState)
    360 {
    361     if (m_assertionState == assertionState)
    362         return;
    363 
    364     RELEASE_LOG(ProcessSuspension, "%p - ProcessAssertion::setState(%u) previousState: %u", this, static_cast<unsigned>(assertionState), static_cast<unsigned>(m_assertionState));
    365     m_assertionState = assertionState;
    366     [m_assertion setFlags:flagsForState(assertionState)];
    367 }
    368 
    369343void ProcessAndUIAssertion::updateRunInBackgroundCount()
    370344{
    371     bool shouldHoldBackgroundTask = validity() != Validity::No && state() != AssertionState::Suspended;
     345    bool shouldHoldBackgroundTask = validity() != Validity::No && type() != ProcessAssertionType::Suspended;
    372346    if (m_isHoldingBackgroundTask == shouldHoldBackgroundTask)
    373347        return;
    … …  
    381355}
    382356
    383 ProcessAndUIAssertion::ProcessAndUIAssertion(pid_t pid, const String& reason, AssertionState assertionState)
    384     : ProcessAssertion(pid, reason, assertionState)
     357ProcessAndUIAssertion::ProcessAndUIAssertion(pid_t pid, const String& reason, ProcessAssertionType assertionType)
     358    : ProcessAssertion(pid, reason, assertionType)
    385359{
    386360    updateRunInBackgroundCount();
    … …  
    393367}
    394368
    395 void ProcessAndUIAssertion::setState(AssertionState assertionState)
    396 {
    397     ProcessAssertion::setState(assertionState);
    398     updateRunInBackgroundCount();
    399 }
    400 
    401369void ProcessAndUIAssertion::uiAssertionWillExpireImminently()
    402370{

  • trunk/Tools/ChangeLog

    r259534 r259540  
     12020-04-04  Chris Dumez  <cdumez@apple.com>
     2
     3        [iOS] Simplify ProcessAssertion class in preparation for switch to RunningBoard
     4        https://bugs.webkit.org/show_bug.cgi?id=209984
     5        <rdar://problem/61273941>
     6
     7        Reviewed by Darin Adler.
     8
     9        * TestWebKitAPI/Tests/WebKitCocoa/ServiceWorkerBasic.mm:
     10
    1112020-04-04  Wenson Hsieh  <wenson_hsieh@apple.com>
    212

  • trunk/Tools/TestWebKitAPI/Tests/WebKitCocoa/ServiceWorkerBasic.mm

    r257614 r259540  
    16661666    waitUntilServiceWorkerProcessCount(processPool, 1);
    16671667
    1668     [webView _setAssertionStateForTesting: 1];
     1668    [webView _setAssertionTypeForTesting: 1];
    16691669    waitUntilServiceWorkerProcessForegroundActivityState(webView.get(), false);
    16701670    waitUntilServiceWorkerProcessBackgroundActivityState(webView.get(), true);
    16711671
    1672     [webView _setAssertionStateForTesting: 3];
     1672    [webView _setAssertionTypeForTesting: 3];
    16731673    waitUntilServiceWorkerProcessForegroundActivityState(webView.get(), true);
    16741674    waitUntilServiceWorkerProcessBackgroundActivityState(webView.get(), false);
    16751675
    1676     [webView _setAssertionStateForTesting: 0];
     1676    [webView _setAssertionTypeForTesting: 0];
    16771677    waitUntilServiceWorkerProcessBackgroundActivityState(webView.get(), false);
    16781678    waitUntilServiceWorkerProcessForegroundActivityState(webView.get(), false);
    … …  
    16861686
    16871687    // The service worker process should take activity based on webView2 process.
    1688     [webView2 _setAssertionStateForTesting: 1];
     1688    [webView2 _setAssertionTypeForTesting: 1];
    16891689    while (webView2.get()._hasServiceWorkerForegroundActivityForTesting || !webView2.get()._hasServiceWorkerBackgroundActivityForTesting) {
    1690         [webView2 _setAssertionStateForTesting: 1];
     1690        [webView2 _setAssertionTypeForTesting: 1];
    16911691        TestWebKitAPI::Util::spinRunLoop(1);
    16921692    }
    16931693
    16941694    while (!webView2.get()._hasServiceWorkerForegroundActivityForTesting || webView2.get()._hasServiceWorkerBackgroundActivityForTesting) {
    1695         [webView2 _setAssertionStateForTesting: 3];
     1695        [webView2 _setAssertionTypeForTesting: 3];
    16961696        TestWebKitAPI::Util::spinRunLoop(1);
    16971697    }
    16981698
    16991699    while (webView2.get()._hasServiceWorkerForegroundActivityForTesting || webView2.get()._hasServiceWorkerBackgroundActivityForTesting) {
    1700         [webView2 _setAssertionStateForTesting: 0];
     1700        [webView2 _setAssertionTypeForTesting: 0];
    17011701        TestWebKitAPI::Util::spinRunLoop(1);
    17021702    }
Note: See TracChangeset for help on using the changeset viewer.